module test.address;

version = XBYAK64;
unittest
{
    import std.stdio;
    import std.string;
    import std.exception;
    import xbyak4d;

    class  gen0 : CodeGenerator
    {
        this()
        {
            mov(ecx, ptr[eax + eax + 0]);
            mov(ecx, ptr[eax + eax + 1]);
            mov(ecx, ptr[eax + eax + 1000]);
            mov(ecx, ptr[eax + eax - 1]);
            mov(ecx, ptr[eax + eax - 1000]);
            mov(ecx, ptr[eax + eax * 1 + 0]);
            mov(ecx, ptr[eax + eax * 1 + 1]);
            mov(ecx, ptr[eax + eax * 1 + 1000]);
            mov(ecx, ptr[eax + eax * 1 - 1]);
            mov(ecx, ptr[eax + eax * 1 - 1000]);
            mov(ecx, ptr[eax + eax * 2 + 0]);
            mov(ecx, ptr[eax + eax * 2 + 1]);
            mov(ecx, ptr[eax + eax * 2 + 1000]);
            mov(ecx, ptr[eax + eax * 2 - 1]);
            mov(ecx, ptr[eax + eax * 2 - 1000]);
            mov(ecx, ptr[eax + eax * 4 + 0]);
            mov(ecx, ptr[eax + eax * 4 + 1]);
            mov(ecx, ptr[eax + eax * 4 + 1000]);
            mov(ecx, ptr[eax + eax * 4 - 1]);
            mov(ecx, ptr[eax + eax * 4 - 1000]);
            mov(ecx, ptr[eax + eax * 8 + 0]);
            mov(ecx, ptr[eax + eax * 8 + 1]);
            mov(ecx, ptr[eax + eax * 8 + 1000]);
            mov(ecx, ptr[eax + eax * 8 - 1]);
            mov(ecx, ptr[eax + eax * 8 - 1000]);
            mov(ecx, ptr[eax + ecx + 0]);
            mov(ecx, ptr[eax + ecx + 1]);
            mov(ecx, ptr[eax + ecx + 1000]);
            mov(ecx, ptr[eax + ecx - 1]);
            mov(ecx, ptr[eax + ecx - 1000]);
            mov(ecx, ptr[eax + ecx * 1 + 0]);
            mov(ecx, ptr[eax + ecx * 1 + 1]);
            mov(ecx, ptr[eax + ecx * 1 + 1000]);
            mov(ecx, ptr[eax + ecx * 1 - 1]);
            mov(ecx, ptr[eax + ecx * 1 - 1000]);
            mov(ecx, ptr[eax + ecx * 2 + 0]);
            mov(ecx, ptr[eax + ecx * 2 + 1]);
            mov(ecx, ptr[eax + ecx * 2 + 1000]);
            mov(ecx, ptr[eax + ecx * 2 - 1]);
            mov(ecx, ptr[eax + ecx * 2 - 1000]);
            mov(ecx, ptr[eax + ecx * 4 + 0]);
            mov(ecx, ptr[eax + ecx * 4 + 1]);
            mov(ecx, ptr[eax + ecx * 4 + 1000]);
            mov(ecx, ptr[eax + ecx * 4 - 1]);
            mov(ecx, ptr[eax + ecx * 4 - 1000]);
            mov(ecx, ptr[eax + ecx * 8 + 0]);
            mov(ecx, ptr[eax + ecx * 8 + 1]);
            mov(ecx, ptr[eax + ecx * 8 + 1000]);
            mov(ecx, ptr[eax + ecx * 8 - 1]);
            mov(ecx, ptr[eax + ecx * 8 - 1000]);
            mov(ecx, ptr[eax + edx + 0]);
            mov(ecx, ptr[eax + edx + 1]);
            mov(ecx, ptr[eax + edx + 1000]);
            mov(ecx, ptr[eax + edx - 1]);
            mov(ecx, ptr[eax + edx - 1000]);
            mov(ecx, ptr[eax + edx * 1 + 0]);
            mov(ecx, ptr[eax + edx * 1 + 1]);
            mov(ecx, ptr[eax + edx * 1 + 1000]);
            mov(ecx, ptr[eax + edx * 1 - 1]);
            mov(ecx, ptr[eax + edx * 1 - 1000]);
            mov(ecx, ptr[eax + edx * 2 + 0]);
            mov(ecx, ptr[eax + edx * 2 + 1]);
            mov(ecx, ptr[eax + edx * 2 + 1000]);
            mov(ecx, ptr[eax + edx * 2 - 1]);
            mov(ecx, ptr[eax + edx * 2 - 1000]);
            mov(ecx, ptr[eax + edx * 4 + 0]);
            mov(ecx, ptr[eax + edx * 4 + 1]);
            mov(ecx, ptr[eax + edx * 4 + 1000]);
            mov(ecx, ptr[eax + edx * 4 - 1]);
            mov(ecx, ptr[eax + edx * 4 - 1000]);
            mov(ecx, ptr[eax + edx * 8 + 0]);
            mov(ecx, ptr[eax + edx * 8 + 1]);
            mov(ecx, ptr[eax + edx * 8 + 1000]);
            mov(ecx, ptr[eax + edx * 8 - 1]);
            mov(ecx, ptr[eax + edx * 8 - 1000]);
            mov(ecx, ptr[eax + ebx + 0]);
            mov(ecx, ptr[eax + ebx + 1]);
            mov(ecx, ptr[eax + ebx + 1000]);
            mov(ecx, ptr[eax + ebx - 1]);
            mov(ecx, ptr[eax + ebx - 1000]);
            mov(ecx, ptr[eax + ebx * 1 + 0]);
            mov(ecx, ptr[eax + ebx * 1 + 1]);
            mov(ecx, ptr[eax + ebx * 1 + 1000]);
            mov(ecx, ptr[eax + ebx * 1 - 1]);
            mov(ecx, ptr[eax + ebx * 1 - 1000]);
            mov(ecx, ptr[eax + ebx * 2 + 0]);
            mov(ecx, ptr[eax + ebx * 2 + 1]);
            mov(ecx, ptr[eax + ebx * 2 + 1000]);
            mov(ecx, ptr[eax + ebx * 2 - 1]);
            mov(ecx, ptr[eax + ebx * 2 - 1000]);
            mov(ecx, ptr[eax + ebx * 4 + 0]);
            mov(ecx, ptr[eax + ebx * 4 + 1]);
            mov(ecx, ptr[eax + ebx * 4 + 1000]);
            mov(ecx, ptr[eax + ebx * 4 - 1]);
            mov(ecx, ptr[eax + ebx * 4 - 1000]);
            mov(ecx, ptr[eax + ebx * 8 + 0]);
            mov(ecx, ptr[eax + ebx * 8 + 1]);
            mov(ecx, ptr[eax + ebx * 8 + 1000]);
            mov(ecx, ptr[eax + ebx * 8 - 1]);
            mov(ecx, ptr[eax + ebx * 8 - 1000]);
        }
    }

    class gen1 : CodeGenerator {
        this()
        {
            mov(ecx, ptr[eax + ebp + 0]);
            mov(ecx, ptr[eax + ebp + 1]);
            mov(ecx, ptr[eax + ebp + 1000]);
            mov(ecx, ptr[eax + ebp - 1]);
            mov(ecx, ptr[eax + ebp - 1000]);
            mov(ecx, ptr[eax + ebp * 1 + 0]);
            mov(ecx, ptr[eax + ebp * 1 + 1]);
            mov(ecx, ptr[eax + ebp * 1 + 1000]);
            mov(ecx, ptr[eax + ebp * 1 - 1]);
            mov(ecx, ptr[eax + ebp * 1 - 1000]);
            mov(ecx, ptr[eax + ebp * 2 + 0]);
            mov(ecx, ptr[eax + ebp * 2 + 1]);
            mov(ecx, ptr[eax + ebp * 2 + 1000]);
            mov(ecx, ptr[eax + ebp * 2 - 1]);
            mov(ecx, ptr[eax + ebp * 2 - 1000]);
            mov(ecx, ptr[eax + ebp * 4 + 0]);
            mov(ecx, ptr[eax + ebp * 4 + 1]);
            mov(ecx, ptr[eax + ebp * 4 + 1000]);
            mov(ecx, ptr[eax + ebp * 4 - 1]);
            mov(ecx, ptr[eax + ebp * 4 - 1000]);
            mov(ecx, ptr[eax + ebp * 8 + 0]);
            mov(ecx, ptr[eax + ebp * 8 + 1]);
            mov(ecx, ptr[eax + ebp * 8 + 1000]);
            mov(ecx, ptr[eax + ebp * 8 - 1]);
            mov(ecx, ptr[eax + ebp * 8 - 1000]);
            mov(ecx, ptr[eax + esi + 0]);
            mov(ecx, ptr[eax + esi + 1]);
            mov(ecx, ptr[eax + esi + 1000]);
            mov(ecx, ptr[eax + esi - 1]);
            mov(ecx, ptr[eax + esi - 1000]);
            mov(ecx, ptr[eax + esi * 1 + 0]);
            mov(ecx, ptr[eax + esi * 1 + 1]);
            mov(ecx, ptr[eax + esi * 1 + 1000]);
            mov(ecx, ptr[eax + esi * 1 - 1]);
            mov(ecx, ptr[eax + esi * 1 - 1000]);
            mov(ecx, ptr[eax + esi * 2 + 0]);
            mov(ecx, ptr[eax + esi * 2 + 1]);
            mov(ecx, ptr[eax + esi * 2 + 1000]);
            mov(ecx, ptr[eax + esi * 2 - 1]);
            mov(ecx, ptr[eax + esi * 2 - 1000]);
            mov(ecx, ptr[eax + esi * 4 + 0]);
            mov(ecx, ptr[eax + esi * 4 + 1]);
            mov(ecx, ptr[eax + esi * 4 + 1000]);
            mov(ecx, ptr[eax + esi * 4 - 1]);
            mov(ecx, ptr[eax + esi * 4 - 1000]);
            mov(ecx, ptr[eax + esi * 8 + 0]);
            mov(ecx, ptr[eax + esi * 8 + 1]);
            mov(ecx, ptr[eax + esi * 8 + 1000]);
            mov(ecx, ptr[eax + esi * 8 - 1]);
            mov(ecx, ptr[eax + esi * 8 - 1000]);
            mov(ecx, ptr[eax + edi + 0]);
            mov(ecx, ptr[eax + edi + 1]);
            mov(ecx, ptr[eax + edi + 1000]);
            mov(ecx, ptr[eax + edi - 1]);
            mov(ecx, ptr[eax + edi - 1000]);
            mov(ecx, ptr[eax + edi * 1 + 0]);
            mov(ecx, ptr[eax + edi * 1 + 1]);
            mov(ecx, ptr[eax + edi * 1 + 1000]);
            mov(ecx, ptr[eax + edi * 1 - 1]);
            mov(ecx, ptr[eax + edi * 1 - 1000]);
            mov(ecx, ptr[eax + edi * 2 + 0]);
            mov(ecx, ptr[eax + edi * 2 + 1]);
            mov(ecx, ptr[eax + edi * 2 + 1000]);
            mov(ecx, ptr[eax + edi * 2 - 1]);
            mov(ecx, ptr[eax + edi * 2 - 1000]);
            mov(ecx, ptr[eax + edi * 4 + 0]);
            mov(ecx, ptr[eax + edi * 4 + 1]);
            mov(ecx, ptr[eax + edi * 4 + 1000]);
            mov(ecx, ptr[eax + edi * 4 - 1]);
            mov(ecx, ptr[eax + edi * 4 - 1000]);
            mov(ecx, ptr[eax + edi * 8 + 0]);
            mov(ecx, ptr[eax + edi * 8 + 1]);
            mov(ecx, ptr[eax + edi * 8 + 1000]);
            mov(ecx, ptr[eax + edi * 8 - 1]);
            mov(ecx, ptr[eax + edi * 8 - 1000]);
            mov(ecx, ptr[eax + r9d + 0]);
            mov(ecx, ptr[eax + r9d + 1]);
            mov(ecx, ptr[eax + r9d + 1000]);
            mov(ecx, ptr[eax + r9d - 1]);
            mov(ecx, ptr[eax + r9d - 1000]);
            mov(ecx, ptr[eax + r9d * 1 + 0]);
            mov(ecx, ptr[eax + r9d * 1 + 1]);
            mov(ecx, ptr[eax + r9d * 1 + 1000]);
            mov(ecx, ptr[eax + r9d * 1 - 1]);
            mov(ecx, ptr[eax + r9d * 1 - 1000]);
            mov(ecx, ptr[eax + r9d * 2 + 0]);
            mov(ecx, ptr[eax + r9d * 2 + 1]);
            mov(ecx, ptr[eax + r9d * 2 + 1000]);
            mov(ecx, ptr[eax + r9d * 2 - 1]);
            mov(ecx, ptr[eax + r9d * 2 - 1000]);
            mov(ecx, ptr[eax + r9d * 4 + 0]);
            mov(ecx, ptr[eax + r9d * 4 + 1]);
            mov(ecx, ptr[eax + r9d * 4 + 1000]);
            mov(ecx, ptr[eax + r9d * 4 - 1]);
            mov(ecx, ptr[eax + r9d * 4 - 1000]);
            mov(ecx, ptr[eax + r9d * 8 + 0]);
            mov(ecx, ptr[eax + r9d * 8 + 1]);
            mov(ecx, ptr[eax + r9d * 8 + 1000]);
            mov(ecx, ptr[eax + r9d * 8 - 1]);
            mov(ecx, ptr[eax + r9d * 8 - 1000]);
        }
    }

    class gen2 : CodeGenerator {
        this()
        {
            mov(ecx, ptr[eax + r10d + 0]);
            mov(ecx, ptr[eax + r10d + 1]);
            mov(ecx, ptr[eax + r10d + 1000]);
            mov(ecx, ptr[eax + r10d - 1]);
            mov(ecx, ptr[eax + r10d - 1000]);
            mov(ecx, ptr[eax + r10d * 1 + 0]);
            mov(ecx, ptr[eax + r10d * 1 + 1]);
            mov(ecx, ptr[eax + r10d * 1 + 1000]);
            mov(ecx, ptr[eax + r10d * 1 - 1]);
            mov(ecx, ptr[eax + r10d * 1 - 1000]);
            mov(ecx, ptr[eax + r10d * 2 + 0]);
            mov(ecx, ptr[eax + r10d * 2 + 1]);
            mov(ecx, ptr[eax + r10d * 2 + 1000]);
            mov(ecx, ptr[eax + r10d * 2 - 1]);
            mov(ecx, ptr[eax + r10d * 2 - 1000]);
            mov(ecx, ptr[eax + r10d * 4 + 0]);
            mov(ecx, ptr[eax + r10d * 4 + 1]);
            mov(ecx, ptr[eax + r10d * 4 + 1000]);
            mov(ecx, ptr[eax + r10d * 4 - 1]);
            mov(ecx, ptr[eax + r10d * 4 - 1000]);
            mov(ecx, ptr[eax + r10d * 8 + 0]);
            mov(ecx, ptr[eax + r10d * 8 + 1]);
            mov(ecx, ptr[eax + r10d * 8 + 1000]);
            mov(ecx, ptr[eax + r10d * 8 - 1]);
            mov(ecx, ptr[eax + r10d * 8 - 1000]);
            mov(ecx, ptr[eax + r11d + 0]);
            mov(ecx, ptr[eax + r11d + 1]);
            mov(ecx, ptr[eax + r11d + 1000]);
            mov(ecx, ptr[eax + r11d - 1]);
            mov(ecx, ptr[eax + r11d - 1000]);
            mov(ecx, ptr[eax + r11d * 1 + 0]);
            mov(ecx, ptr[eax + r11d * 1 + 1]);
            mov(ecx, ptr[eax + r11d * 1 + 1000]);
            mov(ecx, ptr[eax + r11d * 1 - 1]);
            mov(ecx, ptr[eax + r11d * 1 - 1000]);
            mov(ecx, ptr[eax + r11d * 2 + 0]);
            mov(ecx, ptr[eax + r11d * 2 + 1]);
            mov(ecx, ptr[eax + r11d * 2 + 1000]);
            mov(ecx, ptr[eax + r11d * 2 - 1]);
            mov(ecx, ptr[eax + r11d * 2 - 1000]);
            mov(ecx, ptr[eax + r11d * 4 + 0]);
            mov(ecx, ptr[eax + r11d * 4 + 1]);
            mov(ecx, ptr[eax + r11d * 4 + 1000]);
            mov(ecx, ptr[eax + r11d * 4 - 1]);
            mov(ecx, ptr[eax + r11d * 4 - 1000]);
            mov(ecx, ptr[eax + r11d * 8 + 0]);
            mov(ecx, ptr[eax + r11d * 8 + 1]);
            mov(ecx, ptr[eax + r11d * 8 + 1000]);
            mov(ecx, ptr[eax + r11d * 8 - 1]);
            mov(ecx, ptr[eax + r11d * 8 - 1000]);
            mov(ecx, ptr[eax + r12d + 0]);
            mov(ecx, ptr[eax + r12d + 1]);
            mov(ecx, ptr[eax + r12d + 1000]);
            mov(ecx, ptr[eax + r12d - 1]);
            mov(ecx, ptr[eax + r12d - 1000]);
            mov(ecx, ptr[eax + r12d * 1 + 0]);
            mov(ecx, ptr[eax + r12d * 1 + 1]);
            mov(ecx, ptr[eax + r12d * 1 + 1000]);
            mov(ecx, ptr[eax + r12d * 1 - 1]);
            mov(ecx, ptr[eax + r12d * 1 - 1000]);
            mov(ecx, ptr[eax + r12d * 2 + 0]);
            mov(ecx, ptr[eax + r12d * 2 + 1]);
            mov(ecx, ptr[eax + r12d * 2 + 1000]);
            mov(ecx, ptr[eax + r12d * 2 - 1]);
            mov(ecx, ptr[eax + r12d * 2 - 1000]);
            mov(ecx, ptr[eax + r12d * 4 + 0]);
            mov(ecx, ptr[eax + r12d * 4 + 1]);
            mov(ecx, ptr[eax + r12d * 4 + 1000]);
            mov(ecx, ptr[eax + r12d * 4 - 1]);
            mov(ecx, ptr[eax + r12d * 4 - 1000]);
            mov(ecx, ptr[eax + r12d * 8 + 0]);
            mov(ecx, ptr[eax + r12d * 8 + 1]);
            mov(ecx, ptr[eax + r12d * 8 + 1000]);
            mov(ecx, ptr[eax + r12d * 8 - 1]);
            mov(ecx, ptr[eax + r12d * 8 - 1000]);
            mov(ecx, ptr[eax + r13d + 0]);
            mov(ecx, ptr[eax + r13d + 1]);
            mov(ecx, ptr[eax + r13d + 1000]);
            mov(ecx, ptr[eax + r13d - 1]);
            mov(ecx, ptr[eax + r13d - 1000]);
            mov(ecx, ptr[eax + r13d * 1 + 0]);
            mov(ecx, ptr[eax + r13d * 1 + 1]);
            mov(ecx, ptr[eax + r13d * 1 + 1000]);
            mov(ecx, ptr[eax + r13d * 1 - 1]);
            mov(ecx, ptr[eax + r13d * 1 - 1000]);
            mov(ecx, ptr[eax + r13d * 2 + 0]);
            mov(ecx, ptr[eax + r13d * 2 + 1]);
            mov(ecx, ptr[eax + r13d * 2 + 1000]);
            mov(ecx, ptr[eax + r13d * 2 - 1]);
            mov(ecx, ptr[eax + r13d * 2 - 1000]);
            mov(ecx, ptr[eax + r13d * 4 + 0]);
            mov(ecx, ptr[eax + r13d * 4 + 1]);
            mov(ecx, ptr[eax + r13d * 4 + 1000]);
            mov(ecx, ptr[eax + r13d * 4 - 1]);
            mov(ecx, ptr[eax + r13d * 4 - 1000]);
            mov(ecx, ptr[eax + r13d * 8 + 0]);
            mov(ecx, ptr[eax + r13d * 8 + 1]);
            mov(ecx, ptr[eax + r13d * 8 + 1000]);
            mov(ecx, ptr[eax + r13d * 8 - 1]);
            mov(ecx, ptr[eax + r13d * 8 - 1000]);
        }
    }

    class gen3 : CodeGenerator {
        this()
        {
            mov(ecx, ptr[eax + r14d + 0]);
            mov(ecx, ptr[eax + r14d + 1]);
            mov(ecx, ptr[eax + r14d + 1000]);
            mov(ecx, ptr[eax + r14d - 1]);
            mov(ecx, ptr[eax + r14d - 1000]);
            mov(ecx, ptr[eax + r14d * 1 + 0]);
            mov(ecx, ptr[eax + r14d * 1 + 1]);
            mov(ecx, ptr[eax + r14d * 1 + 1000]);
            mov(ecx, ptr[eax + r14d * 1 - 1]);
            mov(ecx, ptr[eax + r14d * 1 - 1000]);
            mov(ecx, ptr[eax + r14d * 2 + 0]);
            mov(ecx, ptr[eax + r14d * 2 + 1]);
            mov(ecx, ptr[eax + r14d * 2 + 1000]);
            mov(ecx, ptr[eax + r14d * 2 - 1]);
            mov(ecx, ptr[eax + r14d * 2 - 1000]);
            mov(ecx, ptr[eax + r14d * 4 + 0]);
            mov(ecx, ptr[eax + r14d * 4 + 1]);
            mov(ecx, ptr[eax + r14d * 4 + 1000]);
            mov(ecx, ptr[eax + r14d * 4 - 1]);
            mov(ecx, ptr[eax + r14d * 4 - 1000]);
            mov(ecx, ptr[eax + r14d * 8 + 0]);
            mov(ecx, ptr[eax + r14d * 8 + 1]);
            mov(ecx, ptr[eax + r14d * 8 + 1000]);
            mov(ecx, ptr[eax + r14d * 8 - 1]);
            mov(ecx, ptr[eax + r14d * 8 - 1000]);
            mov(ecx, ptr[eax + r15d + 0]);
            mov(ecx, ptr[eax + r15d + 1]);
            mov(ecx, ptr[eax + r15d + 1000]);
            mov(ecx, ptr[eax + r15d - 1]);
            mov(ecx, ptr[eax + r15d - 1000]);
            mov(ecx, ptr[eax + r15d * 1 + 0]);
            mov(ecx, ptr[eax + r15d * 1 + 1]);
            mov(ecx, ptr[eax + r15d * 1 + 1000]);
            mov(ecx, ptr[eax + r15d * 1 - 1]);
            mov(ecx, ptr[eax + r15d * 1 - 1000]);
            mov(ecx, ptr[eax + r15d * 2 + 0]);
            mov(ecx, ptr[eax + r15d * 2 + 1]);
            mov(ecx, ptr[eax + r15d * 2 + 1000]);
            mov(ecx, ptr[eax + r15d * 2 - 1]);
            mov(ecx, ptr[eax + r15d * 2 - 1000]);
            mov(ecx, ptr[eax + r15d * 4 + 0]);
            mov(ecx, ptr[eax + r15d * 4 + 1]);
            mov(ecx, ptr[eax + r15d * 4 + 1000]);
            mov(ecx, ptr[eax + r15d * 4 - 1]);
            mov(ecx, ptr[eax + r15d * 4 - 1000]);
            mov(ecx, ptr[eax + r15d * 8 + 0]);
            mov(ecx, ptr[eax + r15d * 8 + 1]);
            mov(ecx, ptr[eax + r15d * 8 + 1000]);
            mov(ecx, ptr[eax + r15d * 8 - 1]);
            mov(ecx, ptr[eax + r15d * 8 - 1000]);
            mov(ecx, ptr[ecx + eax + 0]);
            mov(ecx, ptr[ecx + eax + 1]);
            mov(ecx, ptr[ecx + eax + 1000]);
            mov(ecx, ptr[ecx + eax - 1]);
            mov(ecx, ptr[ecx + eax - 1000]);
            mov(ecx, ptr[ecx + eax * 1 + 0]);
            mov(ecx, ptr[ecx + eax * 1 + 1]);
            mov(ecx, ptr[ecx + eax * 1 + 1000]);
            mov(ecx, ptr[ecx + eax * 1 - 1]);
            mov(ecx, ptr[ecx + eax * 1 - 1000]);
            mov(ecx, ptr[ecx + eax * 2 + 0]);
            mov(ecx, ptr[ecx + eax * 2 + 1]);
            mov(ecx, ptr[ecx + eax * 2 + 1000]);
            mov(ecx, ptr[ecx + eax * 2 - 1]);
            mov(ecx, ptr[ecx + eax * 2 - 1000]);
            mov(ecx, ptr[ecx + eax * 4 + 0]);
            mov(ecx, ptr[ecx + eax * 4 + 1]);
            mov(ecx, ptr[ecx + eax * 4 + 1000]);
            mov(ecx, ptr[ecx + eax * 4 - 1]);
            mov(ecx, ptr[ecx + eax * 4 - 1000]);
            mov(ecx, ptr[ecx + eax * 8 + 0]);
            mov(ecx, ptr[ecx + eax * 8 + 1]);
            mov(ecx, ptr[ecx + eax * 8 + 1000]);
            mov(ecx, ptr[ecx + eax * 8 - 1]);
            mov(ecx, ptr[ecx + eax * 8 - 1000]);
            mov(ecx, ptr[ecx + ecx + 0]);
            mov(ecx, ptr[ecx + ecx + 1]);
            mov(ecx, ptr[ecx + ecx + 1000]);
            mov(ecx, ptr[ecx + ecx - 1]);
            mov(ecx, ptr[ecx + ecx - 1000]);
            mov(ecx, ptr[ecx + ecx * 1 + 0]);
            mov(ecx, ptr[ecx + ecx * 1 + 1]);
            mov(ecx, ptr[ecx + ecx * 1 + 1000]);
            mov(ecx, ptr[ecx + ecx * 1 - 1]);
            mov(ecx, ptr[ecx + ecx * 1 - 1000]);
            mov(ecx, ptr[ecx + ecx * 2 + 0]);
            mov(ecx, ptr[ecx + ecx * 2 + 1]);
            mov(ecx, ptr[ecx + ecx * 2 + 1000]);
            mov(ecx, ptr[ecx + ecx * 2 - 1]);
            mov(ecx, ptr[ecx + ecx * 2 - 1000]);
            mov(ecx, ptr[ecx + ecx * 4 + 0]);
            mov(ecx, ptr[ecx + ecx * 4 + 1]);
            mov(ecx, ptr[ecx + ecx * 4 + 1000]);
            mov(ecx, ptr[ecx + ecx * 4 - 1]);
            mov(ecx, ptr[ecx + ecx * 4 - 1000]);
            mov(ecx, ptr[ecx + ecx * 8 + 0]);
            mov(ecx, ptr[ecx + ecx * 8 + 1]);
            mov(ecx, ptr[ecx + ecx * 8 + 1000]);
            mov(ecx, ptr[ecx + ecx * 8 - 1]);
            mov(ecx, ptr[ecx + ecx * 8 - 1000]);
        }
    }

    class gen4 : CodeGenerator {
        this()
        {
            mov(ecx, ptr[ecx + edx + 0]);
            mov(ecx, ptr[ecx + edx + 1]);
            mov(ecx, ptr[ecx + edx + 1000]);
            mov(ecx, ptr[ecx + edx - 1]);
            mov(ecx, ptr[ecx + edx - 1000]);
            mov(ecx, ptr[ecx + edx * 1 + 0]);
            mov(ecx, ptr[ecx + edx * 1 + 1]);
            mov(ecx, ptr[ecx + edx * 1 + 1000]);
            mov(ecx, ptr[ecx + edx * 1 - 1]);
            mov(ecx, ptr[ecx + edx * 1 - 1000]);
            mov(ecx, ptr[ecx + edx * 2 + 0]);
            mov(ecx, ptr[ecx + edx * 2 + 1]);
            mov(ecx, ptr[ecx + edx * 2 + 1000]);
            mov(ecx, ptr[ecx + edx * 2 - 1]);
            mov(ecx, ptr[ecx + edx * 2 - 1000]);
            mov(ecx, ptr[ecx + edx * 4 + 0]);
            mov(ecx, ptr[ecx + edx * 4 + 1]);
            mov(ecx, ptr[ecx + edx * 4 + 1000]);
            mov(ecx, ptr[ecx + edx * 4 - 1]);
            mov(ecx, ptr[ecx + edx * 4 - 1000]);
            mov(ecx, ptr[ecx + edx * 8 + 0]);
            mov(ecx, ptr[ecx + edx * 8 + 1]);
            mov(ecx, ptr[ecx + edx * 8 + 1000]);
            mov(ecx, ptr[ecx + edx * 8 - 1]);
            mov(ecx, ptr[ecx + edx * 8 - 1000]);
            mov(ecx, ptr[ecx + ebx + 0]);
            mov(ecx, ptr[ecx + ebx + 1]);
            mov(ecx, ptr[ecx + ebx + 1000]);
            mov(ecx, ptr[ecx + ebx - 1]);
            mov(ecx, ptr[ecx + ebx - 1000]);
            mov(ecx, ptr[ecx + ebx * 1 + 0]);
            mov(ecx, ptr[ecx + ebx * 1 + 1]);
            mov(ecx, ptr[ecx + ebx * 1 + 1000]);
            mov(ecx, ptr[ecx + ebx * 1 - 1]);
            mov(ecx, ptr[ecx + ebx * 1 - 1000]);
            mov(ecx, ptr[ecx + ebx * 2 + 0]);
            mov(ecx, ptr[ecx + ebx * 2 + 1]);
            mov(ecx, ptr[ecx + ebx * 2 + 1000]);
            mov(ecx, ptr[ecx + ebx * 2 - 1]);
            mov(ecx, ptr[ecx + ebx * 2 - 1000]);
            mov(ecx, ptr[ecx + ebx * 4 + 0]);
            mov(ecx, ptr[ecx + ebx * 4 + 1]);
            mov(ecx, ptr[ecx + ebx * 4 + 1000]);
            mov(ecx, ptr[ecx + ebx * 4 - 1]);
            mov(ecx, ptr[ecx + ebx * 4 - 1000]);
            mov(ecx, ptr[ecx + ebx * 8 + 0]);
            mov(ecx, ptr[ecx + ebx * 8 + 1]);
            mov(ecx, ptr[ecx + ebx * 8 + 1000]);
            mov(ecx, ptr[ecx + ebx * 8 - 1]);
            mov(ecx, ptr[ecx + ebx * 8 - 1000]);
            mov(ecx, ptr[ecx + ebp + 0]);
            mov(ecx, ptr[ecx + ebp + 1]);
            mov(ecx, ptr[ecx + ebp + 1000]);
            mov(ecx, ptr[ecx + ebp - 1]);
            mov(ecx, ptr[ecx + ebp - 1000]);
            mov(ecx, ptr[ecx + ebp * 1 + 0]);
            mov(ecx, ptr[ecx + ebp * 1 + 1]);
            mov(ecx, ptr[ecx + ebp * 1 + 1000]);
            mov(ecx, ptr[ecx + ebp * 1 - 1]);
            mov(ecx, ptr[ecx + ebp * 1 - 1000]);
            mov(ecx, ptr[ecx + ebp * 2 + 0]);
            mov(ecx, ptr[ecx + ebp * 2 + 1]);
            mov(ecx, ptr[ecx + ebp * 2 + 1000]);
            mov(ecx, ptr[ecx + ebp * 2 - 1]);
            mov(ecx, ptr[ecx + ebp * 2 - 1000]);
            mov(ecx, ptr[ecx + ebp * 4 + 0]);
            mov(ecx, ptr[ecx + ebp * 4 + 1]);
            mov(ecx, ptr[ecx + ebp * 4 + 1000]);
            mov(ecx, ptr[ecx + ebp * 4 - 1]);
            mov(ecx, ptr[ecx + ebp * 4 - 1000]);
            mov(ecx, ptr[ecx + ebp * 8 + 0]);
            mov(ecx, ptr[ecx + ebp * 8 + 1]);
            mov(ecx, ptr[ecx + ebp * 8 + 1000]);
            mov(ecx, ptr[ecx + ebp * 8 - 1]);
            mov(ecx, ptr[ecx + ebp * 8 - 1000]);
            mov(ecx, ptr[ecx + esi + 0]);
            mov(ecx, ptr[ecx + esi + 1]);
            mov(ecx, ptr[ecx + esi + 1000]);
            mov(ecx, ptr[ecx + esi - 1]);
            mov(ecx, ptr[ecx + esi - 1000]);
            mov(ecx, ptr[ecx + esi * 1 + 0]);
            mov(ecx, ptr[ecx + esi * 1 + 1]);
            mov(ecx, ptr[ecx + esi * 1 + 1000]);
            mov(ecx, ptr[ecx + esi * 1 - 1]);
            mov(ecx, ptr[ecx + esi * 1 - 1000]);
            mov(ecx, ptr[ecx + esi * 2 + 0]);
            mov(ecx, ptr[ecx + esi * 2 + 1]);
            mov(ecx, ptr[ecx + esi * 2 + 1000]);
            mov(ecx, ptr[ecx + esi * 2 - 1]);
            mov(ecx, ptr[ecx + esi * 2 - 1000]);
            mov(ecx, ptr[ecx + esi * 4 + 0]);
            mov(ecx, ptr[ecx + esi * 4 + 1]);
            mov(ecx, ptr[ecx + esi * 4 + 1000]);
            mov(ecx, ptr[ecx + esi * 4 - 1]);
            mov(ecx, ptr[ecx + esi * 4 - 1000]);
            mov(ecx, ptr[ecx + esi * 8 + 0]);
            mov(ecx, ptr[ecx + esi * 8 + 1]);
            mov(ecx, ptr[ecx + esi * 8 + 1000]);
            mov(ecx, ptr[ecx + esi * 8 - 1]);
            mov(ecx, ptr[ecx + esi * 8 - 1000]);
        }
    }

    class gen5 : CodeGenerator {
        this()
        {
            mov(ecx, ptr[ecx + edi + 0]);
            mov(ecx, ptr[ecx + edi + 1]);
            mov(ecx, ptr[ecx + edi + 1000]);
            mov(ecx, ptr[ecx + edi - 1]);
            mov(ecx, ptr[ecx + edi - 1000]);
            mov(ecx, ptr[ecx + edi * 1 + 0]);
            mov(ecx, ptr[ecx + edi * 1 + 1]);
            mov(ecx, ptr[ecx + edi * 1 + 1000]);
            mov(ecx, ptr[ecx + edi * 1 - 1]);
            mov(ecx, ptr[ecx + edi * 1 - 1000]);
            mov(ecx, ptr[ecx + edi * 2 + 0]);
            mov(ecx, ptr[ecx + edi * 2 + 1]);
            mov(ecx, ptr[ecx + edi * 2 + 1000]);
            mov(ecx, ptr[ecx + edi * 2 - 1]);
            mov(ecx, ptr[ecx + edi * 2 - 1000]);
            mov(ecx, ptr[ecx + edi * 4 + 0]);
            mov(ecx, ptr[ecx + edi * 4 + 1]);
            mov(ecx, ptr[ecx + edi * 4 + 1000]);
            mov(ecx, ptr[ecx + edi * 4 - 1]);
            mov(ecx, ptr[ecx + edi * 4 - 1000]);
            mov(ecx, ptr[ecx + edi * 8 + 0]);
            mov(ecx, ptr[ecx + edi * 8 + 1]);
            mov(ecx, ptr[ecx + edi * 8 + 1000]);
            mov(ecx, ptr[ecx + edi * 8 - 1]);
            mov(ecx, ptr[ecx + edi * 8 - 1000]);
            mov(ecx, ptr[ecx + r9d + 0]);
            mov(ecx, ptr[ecx + r9d + 1]);
            mov(ecx, ptr[ecx + r9d + 1000]);
            mov(ecx, ptr[ecx + r9d - 1]);
            mov(ecx, ptr[ecx + r9d - 1000]);
            mov(ecx, ptr[ecx + r9d * 1 + 0]);
            mov(ecx, ptr[ecx + r9d * 1 + 1]);
            mov(ecx, ptr[ecx + r9d * 1 + 1000]);
            mov(ecx, ptr[ecx + r9d * 1 - 1]);
            mov(ecx, ptr[ecx + r9d * 1 - 1000]);
            mov(ecx, ptr[ecx + r9d * 2 + 0]);
            mov(ecx, ptr[ecx + r9d * 2 + 1]);
            mov(ecx, ptr[ecx + r9d * 2 + 1000]);
            mov(ecx, ptr[ecx + r9d * 2 - 1]);
            mov(ecx, ptr[ecx + r9d * 2 - 1000]);
            mov(ecx, ptr[ecx + r9d * 4 + 0]);
            mov(ecx, ptr[ecx + r9d * 4 + 1]);
            mov(ecx, ptr[ecx + r9d * 4 + 1000]);
            mov(ecx, ptr[ecx + r9d * 4 - 1]);
            mov(ecx, ptr[ecx + r9d * 4 - 1000]);
            mov(ecx, ptr[ecx + r9d * 8 + 0]);
            mov(ecx, ptr[ecx + r9d * 8 + 1]);
            mov(ecx, ptr[ecx + r9d * 8 + 1000]);
            mov(ecx, ptr[ecx + r9d * 8 - 1]);
            mov(ecx, ptr[ecx + r9d * 8 - 1000]);
            mov(ecx, ptr[ecx + r10d + 0]);
            mov(ecx, ptr[ecx + r10d + 1]);
            mov(ecx, ptr[ecx + r10d + 1000]);
            mov(ecx, ptr[ecx + r10d - 1]);
            mov(ecx, ptr[ecx + r10d - 1000]);
            mov(ecx, ptr[ecx + r10d * 1 + 0]);
            mov(ecx, ptr[ecx + r10d * 1 + 1]);
            mov(ecx, ptr[ecx + r10d * 1 + 1000]);
            mov(ecx, ptr[ecx + r10d * 1 - 1]);
            mov(ecx, ptr[ecx + r10d * 1 - 1000]);
            mov(ecx, ptr[ecx + r10d * 2 + 0]);
            mov(ecx, ptr[ecx + r10d * 2 + 1]);
            mov(ecx, ptr[ecx + r10d * 2 + 1000]);
            mov(ecx, ptr[ecx + r10d * 2 - 1]);
            mov(ecx, ptr[ecx + r10d * 2 - 1000]);
            mov(ecx, ptr[ecx + r10d * 4 + 0]);
            mov(ecx, ptr[ecx + r10d * 4 + 1]);
            mov(ecx, ptr[ecx + r10d * 4 + 1000]);
            mov(ecx, ptr[ecx + r10d * 4 - 1]);
            mov(ecx, ptr[ecx + r10d * 4 - 1000]);
            mov(ecx, ptr[ecx + r10d * 8 + 0]);
            mov(ecx, ptr[ecx + r10d * 8 + 1]);
            mov(ecx, ptr[ecx + r10d * 8 + 1000]);
            mov(ecx, ptr[ecx + r10d * 8 - 1]);
            mov(ecx, ptr[ecx + r10d * 8 - 1000]);
            mov(ecx, ptr[ecx + r11d + 0]);
            mov(ecx, ptr[ecx + r11d + 1]);
            mov(ecx, ptr[ecx + r11d + 1000]);
            mov(ecx, ptr[ecx + r11d - 1]);
            mov(ecx, ptr[ecx + r11d - 1000]);
            mov(ecx, ptr[ecx + r11d * 1 + 0]);
            mov(ecx, ptr[ecx + r11d * 1 + 1]);
            mov(ecx, ptr[ecx + r11d * 1 + 1000]);
            mov(ecx, ptr[ecx + r11d * 1 - 1]);
            mov(ecx, ptr[ecx + r11d * 1 - 1000]);
            mov(ecx, ptr[ecx + r11d * 2 + 0]);
            mov(ecx, ptr[ecx + r11d * 2 + 1]);
            mov(ecx, ptr[ecx + r11d * 2 + 1000]);
            mov(ecx, ptr[ecx + r11d * 2 - 1]);
            mov(ecx, ptr[ecx + r11d * 2 - 1000]);
            mov(ecx, ptr[ecx + r11d * 4 + 0]);
            mov(ecx, ptr[ecx + r11d * 4 + 1]);
            mov(ecx, ptr[ecx + r11d * 4 + 1000]);
            mov(ecx, ptr[ecx + r11d * 4 - 1]);
            mov(ecx, ptr[ecx + r11d * 4 - 1000]);
            mov(ecx, ptr[ecx + r11d * 8 + 0]);
            mov(ecx, ptr[ecx + r11d * 8 + 1]);
            mov(ecx, ptr[ecx + r11d * 8 + 1000]);
            mov(ecx, ptr[ecx + r11d * 8 - 1]);
            mov(ecx, ptr[ecx + r11d * 8 - 1000]);
        }
    }

    class gen6 : CodeGenerator {
        this()
        {
            mov(ecx, ptr[ecx + r12d + 0]);
            mov(ecx, ptr[ecx + r12d + 1]);
            mov(ecx, ptr[ecx + r12d + 1000]);
            mov(ecx, ptr[ecx + r12d - 1]);
            mov(ecx, ptr[ecx + r12d - 1000]);
            mov(ecx, ptr[ecx + r12d * 1 + 0]);
            mov(ecx, ptr[ecx + r12d * 1 + 1]);
            mov(ecx, ptr[ecx + r12d * 1 + 1000]);
            mov(ecx, ptr[ecx + r12d * 1 - 1]);
            mov(ecx, ptr[ecx + r12d * 1 - 1000]);
            mov(ecx, ptr[ecx + r12d * 2 + 0]);
            mov(ecx, ptr[ecx + r12d * 2 + 1]);
            mov(ecx, ptr[ecx + r12d * 2 + 1000]);
            mov(ecx, ptr[ecx + r12d * 2 - 1]);
            mov(ecx, ptr[ecx + r12d * 2 - 1000]);
            mov(ecx, ptr[ecx + r12d * 4 + 0]);
            mov(ecx, ptr[ecx + r12d * 4 + 1]);
            mov(ecx, ptr[ecx + r12d * 4 + 1000]);
            mov(ecx, ptr[ecx + r12d * 4 - 1]);
            mov(ecx, ptr[ecx + r12d * 4 - 1000]);
            mov(ecx, ptr[ecx + r12d * 8 + 0]);
            mov(ecx, ptr[ecx + r12d * 8 + 1]);
            mov(ecx, ptr[ecx + r12d * 8 + 1000]);
            mov(ecx, ptr[ecx + r12d * 8 - 1]);
            mov(ecx, ptr[ecx + r12d * 8 - 1000]);
            mov(ecx, ptr[ecx + r13d + 0]);
            mov(ecx, ptr[ecx + r13d + 1]);
            mov(ecx, ptr[ecx + r13d + 1000]);
            mov(ecx, ptr[ecx + r13d - 1]);
            mov(ecx, ptr[ecx + r13d - 1000]);
            mov(ecx, ptr[ecx + r13d * 1 + 0]);
            mov(ecx, ptr[ecx + r13d * 1 + 1]);
            mov(ecx, ptr[ecx + r13d * 1 + 1000]);
            mov(ecx, ptr[ecx + r13d * 1 - 1]);
            mov(ecx, ptr[ecx + r13d * 1 - 1000]);
            mov(ecx, ptr[ecx + r13d * 2 + 0]);
            mov(ecx, ptr[ecx + r13d * 2 + 1]);
            mov(ecx, ptr[ecx + r13d * 2 + 1000]);
            mov(ecx, ptr[ecx + r13d * 2 - 1]);
            mov(ecx, ptr[ecx + r13d * 2 - 1000]);
            mov(ecx, ptr[ecx + r13d * 4 + 0]);
            mov(ecx, ptr[ecx + r13d * 4 + 1]);
            mov(ecx, ptr[ecx + r13d * 4 + 1000]);
            mov(ecx, ptr[ecx + r13d * 4 - 1]);
            mov(ecx, ptr[ecx + r13d * 4 - 1000]);
            mov(ecx, ptr[ecx + r13d * 8 + 0]);
            mov(ecx, ptr[ecx + r13d * 8 + 1]);
            mov(ecx, ptr[ecx + r13d * 8 + 1000]);
            mov(ecx, ptr[ecx + r13d * 8 - 1]);
            mov(ecx, ptr[ecx + r13d * 8 - 1000]);
            mov(ecx, ptr[ecx + r14d + 0]);
            mov(ecx, ptr[ecx + r14d + 1]);
            mov(ecx, ptr[ecx + r14d + 1000]);
            mov(ecx, ptr[ecx + r14d - 1]);
            mov(ecx, ptr[ecx + r14d - 1000]);
            mov(ecx, ptr[ecx + r14d * 1 + 0]);
            mov(ecx, ptr[ecx + r14d * 1 + 1]);
            mov(ecx, ptr[ecx + r14d * 1 + 1000]);
            mov(ecx, ptr[ecx + r14d * 1 - 1]);
            mov(ecx, ptr[ecx + r14d * 1 - 1000]);
            mov(ecx, ptr[ecx + r14d * 2 + 0]);
            mov(ecx, ptr[ecx + r14d * 2 + 1]);
            mov(ecx, ptr[ecx + r14d * 2 + 1000]);
            mov(ecx, ptr[ecx + r14d * 2 - 1]);
            mov(ecx, ptr[ecx + r14d * 2 - 1000]);
            mov(ecx, ptr[ecx + r14d * 4 + 0]);
            mov(ecx, ptr[ecx + r14d * 4 + 1]);
            mov(ecx, ptr[ecx + r14d * 4 + 1000]);
            mov(ecx, ptr[ecx + r14d * 4 - 1]);
            mov(ecx, ptr[ecx + r14d * 4 - 1000]);
            mov(ecx, ptr[ecx + r14d * 8 + 0]);
            mov(ecx, ptr[ecx + r14d * 8 + 1]);
            mov(ecx, ptr[ecx + r14d * 8 + 1000]);
            mov(ecx, ptr[ecx + r14d * 8 - 1]);
            mov(ecx, ptr[ecx + r14d * 8 - 1000]);
            mov(ecx, ptr[ecx + r15d + 0]);
            mov(ecx, ptr[ecx + r15d + 1]);
            mov(ecx, ptr[ecx + r15d + 1000]);
            mov(ecx, ptr[ecx + r15d - 1]);
            mov(ecx, ptr[ecx + r15d - 1000]);
            mov(ecx, ptr[ecx + r15d * 1 + 0]);
            mov(ecx, ptr[ecx + r15d * 1 + 1]);
            mov(ecx, ptr[ecx + r15d * 1 + 1000]);
            mov(ecx, ptr[ecx + r15d * 1 - 1]);
            mov(ecx, ptr[ecx + r15d * 1 - 1000]);
            mov(ecx, ptr[ecx + r15d * 2 + 0]);
            mov(ecx, ptr[ecx + r15d * 2 + 1]);
            mov(ecx, ptr[ecx + r15d * 2 + 1000]);
            mov(ecx, ptr[ecx + r15d * 2 - 1]);
            mov(ecx, ptr[ecx + r15d * 2 - 1000]);
            mov(ecx, ptr[ecx + r15d * 4 + 0]);
            mov(ecx, ptr[ecx + r15d * 4 + 1]);
            mov(ecx, ptr[ecx + r15d * 4 + 1000]);
            mov(ecx, ptr[ecx + r15d * 4 - 1]);
            mov(ecx, ptr[ecx + r15d * 4 - 1000]);
            mov(ecx, ptr[ecx + r15d * 8 + 0]);
            mov(ecx, ptr[ecx + r15d * 8 + 1]);
            mov(ecx, ptr[ecx + r15d * 8 + 1000]);
            mov(ecx, ptr[ecx + r15d * 8 - 1]);
            mov(ecx, ptr[ecx + r15d * 8 - 1000]);
        }
    }

    class gen7 : CodeGenerator {
        this()
        {
            mov(ecx, ptr[edx + eax + 0]);
            mov(ecx, ptr[edx + eax + 1]);
            mov(ecx, ptr[edx + eax + 1000]);
            mov(ecx, ptr[edx + eax - 1]);
            mov(ecx, ptr[edx + eax - 1000]);
            mov(ecx, ptr[edx + eax * 1 + 0]);
            mov(ecx, ptr[edx + eax * 1 + 1]);
            mov(ecx, ptr[edx + eax * 1 + 1000]);
            mov(ecx, ptr[edx + eax * 1 - 1]);
            mov(ecx, ptr[edx + eax * 1 - 1000]);
            mov(ecx, ptr[edx + eax * 2 + 0]);
            mov(ecx, ptr[edx + eax * 2 + 1]);
            mov(ecx, ptr[edx + eax * 2 + 1000]);
            mov(ecx, ptr[edx + eax * 2 - 1]);
            mov(ecx, ptr[edx + eax * 2 - 1000]);
            mov(ecx, ptr[edx + eax * 4 + 0]);
            mov(ecx, ptr[edx + eax * 4 + 1]);
            mov(ecx, ptr[edx + eax * 4 + 1000]);
            mov(ecx, ptr[edx + eax * 4 - 1]);
            mov(ecx, ptr[edx + eax * 4 - 1000]);
            mov(ecx, ptr[edx + eax * 8 + 0]);
            mov(ecx, ptr[edx + eax * 8 + 1]);
            mov(ecx, ptr[edx + eax * 8 + 1000]);
            mov(ecx, ptr[edx + eax * 8 - 1]);
            mov(ecx, ptr[edx + eax * 8 - 1000]);
            mov(ecx, ptr[edx + ecx + 0]);
            mov(ecx, ptr[edx + ecx + 1]);
            mov(ecx, ptr[edx + ecx + 1000]);
            mov(ecx, ptr[edx + ecx - 1]);
            mov(ecx, ptr[edx + ecx - 1000]);
            mov(ecx, ptr[edx + ecx * 1 + 0]);
            mov(ecx, ptr[edx + ecx * 1 + 1]);
            mov(ecx, ptr[edx + ecx * 1 + 1000]);
            mov(ecx, ptr[edx + ecx * 1 - 1]);
            mov(ecx, ptr[edx + ecx * 1 - 1000]);
            mov(ecx, ptr[edx + ecx * 2 + 0]);
            mov(ecx, ptr[edx + ecx * 2 + 1]);
            mov(ecx, ptr[edx + ecx * 2 + 1000]);
            mov(ecx, ptr[edx + ecx * 2 - 1]);
            mov(ecx, ptr[edx + ecx * 2 - 1000]);
            mov(ecx, ptr[edx + ecx * 4 + 0]);
            mov(ecx, ptr[edx + ecx * 4 + 1]);
            mov(ecx, ptr[edx + ecx * 4 + 1000]);
            mov(ecx, ptr[edx + ecx * 4 - 1]);
            mov(ecx, ptr[edx + ecx * 4 - 1000]);
            mov(ecx, ptr[edx + ecx * 8 + 0]);
            mov(ecx, ptr[edx + ecx * 8 + 1]);
            mov(ecx, ptr[edx + ecx * 8 + 1000]);
            mov(ecx, ptr[edx + ecx * 8 - 1]);
            mov(ecx, ptr[edx + ecx * 8 - 1000]);
            mov(ecx, ptr[edx + edx + 0]);
            mov(ecx, ptr[edx + edx + 1]);
            mov(ecx, ptr[edx + edx + 1000]);
            mov(ecx, ptr[edx + edx - 1]);
            mov(ecx, ptr[edx + edx - 1000]);
            mov(ecx, ptr[edx + edx * 1 + 0]);
            mov(ecx, ptr[edx + edx * 1 + 1]);
            mov(ecx, ptr[edx + edx * 1 + 1000]);
            mov(ecx, ptr[edx + edx * 1 - 1]);
            mov(ecx, ptr[edx + edx * 1 - 1000]);
            mov(ecx, ptr[edx + edx * 2 + 0]);
            mov(ecx, ptr[edx + edx * 2 + 1]);
            mov(ecx, ptr[edx + edx * 2 + 1000]);
            mov(ecx, ptr[edx + edx * 2 - 1]);
            mov(ecx, ptr[edx + edx * 2 - 1000]);
            mov(ecx, ptr[edx + edx * 4 + 0]);
            mov(ecx, ptr[edx + edx * 4 + 1]);
            mov(ecx, ptr[edx + edx * 4 + 1000]);
            mov(ecx, ptr[edx + edx * 4 - 1]);
            mov(ecx, ptr[edx + edx * 4 - 1000]);
            mov(ecx, ptr[edx + edx * 8 + 0]);
            mov(ecx, ptr[edx + edx * 8 + 1]);
            mov(ecx, ptr[edx + edx * 8 + 1000]);
            mov(ecx, ptr[edx + edx * 8 - 1]);
            mov(ecx, ptr[edx + edx * 8 - 1000]);
            mov(ecx, ptr[edx + ebx + 0]);
            mov(ecx, ptr[edx + ebx + 1]);
            mov(ecx, ptr[edx + ebx + 1000]);
            mov(ecx, ptr[edx + ebx - 1]);
            mov(ecx, ptr[edx + ebx - 1000]);
            mov(ecx, ptr[edx + ebx * 1 + 0]);
            mov(ecx, ptr[edx + ebx * 1 + 1]);
            mov(ecx, ptr[edx + ebx * 1 + 1000]);
            mov(ecx, ptr[edx + ebx * 1 - 1]);
            mov(ecx, ptr[edx + ebx * 1 - 1000]);
            mov(ecx, ptr[edx + ebx * 2 + 0]);
            mov(ecx, ptr[edx + ebx * 2 + 1]);
            mov(ecx, ptr[edx + ebx * 2 + 1000]);
            mov(ecx, ptr[edx + ebx * 2 - 1]);
            mov(ecx, ptr[edx + ebx * 2 - 1000]);
            mov(ecx, ptr[edx + ebx * 4 + 0]);
            mov(ecx, ptr[edx + ebx * 4 + 1]);
            mov(ecx, ptr[edx + ebx * 4 + 1000]);
            mov(ecx, ptr[edx + ebx * 4 - 1]);
            mov(ecx, ptr[edx + ebx * 4 - 1000]);
            mov(ecx, ptr[edx + ebx * 8 + 0]);
            mov(ecx, ptr[edx + ebx * 8 + 1]);
            mov(ecx, ptr[edx + ebx * 8 + 1000]);
            mov(ecx, ptr[edx + ebx * 8 - 1]);
            mov(ecx, ptr[edx + ebx * 8 - 1000]);
        }
    }

    class gen8 : CodeGenerator {
        this()
        {
            mov(ecx, ptr[edx + ebp + 0]);
            mov(ecx, ptr[edx + ebp + 1]);
            mov(ecx, ptr[edx + ebp + 1000]);
            mov(ecx, ptr[edx + ebp - 1]);
            mov(ecx, ptr[edx + ebp - 1000]);
            mov(ecx, ptr[edx + ebp * 1 + 0]);
            mov(ecx, ptr[edx + ebp * 1 + 1]);
            mov(ecx, ptr[edx + ebp * 1 + 1000]);
            mov(ecx, ptr[edx + ebp * 1 - 1]);
            mov(ecx, ptr[edx + ebp * 1 - 1000]);
            mov(ecx, ptr[edx + ebp * 2 + 0]);
            mov(ecx, ptr[edx + ebp * 2 + 1]);
            mov(ecx, ptr[edx + ebp * 2 + 1000]);
            mov(ecx, ptr[edx + ebp * 2 - 1]);
            mov(ecx, ptr[edx + ebp * 2 - 1000]);
            mov(ecx, ptr[edx + ebp * 4 + 0]);
            mov(ecx, ptr[edx + ebp * 4 + 1]);
            mov(ecx, ptr[edx + ebp * 4 + 1000]);
            mov(ecx, ptr[edx + ebp * 4 - 1]);
            mov(ecx, ptr[edx + ebp * 4 - 1000]);
            mov(ecx, ptr[edx + ebp * 8 + 0]);
            mov(ecx, ptr[edx + ebp * 8 + 1]);
            mov(ecx, ptr[edx + ebp * 8 + 1000]);
            mov(ecx, ptr[edx + ebp * 8 - 1]);
            mov(ecx, ptr[edx + ebp * 8 - 1000]);
            mov(ecx, ptr[edx + esi + 0]);
            mov(ecx, ptr[edx + esi + 1]);
            mov(ecx, ptr[edx + esi + 1000]);
            mov(ecx, ptr[edx + esi - 1]);
            mov(ecx, ptr[edx + esi - 1000]);
            mov(ecx, ptr[edx + esi * 1 + 0]);
            mov(ecx, ptr[edx + esi * 1 + 1]);
            mov(ecx, ptr[edx + esi * 1 + 1000]);
            mov(ecx, ptr[edx + esi * 1 - 1]);
            mov(ecx, ptr[edx + esi * 1 - 1000]);
            mov(ecx, ptr[edx + esi * 2 + 0]);
            mov(ecx, ptr[edx + esi * 2 + 1]);
            mov(ecx, ptr[edx + esi * 2 + 1000]);
            mov(ecx, ptr[edx + esi * 2 - 1]);
            mov(ecx, ptr[edx + esi * 2 - 1000]);
            mov(ecx, ptr[edx + esi * 4 + 0]);
            mov(ecx, ptr[edx + esi * 4 + 1]);
            mov(ecx, ptr[edx + esi * 4 + 1000]);
            mov(ecx, ptr[edx + esi * 4 - 1]);
            mov(ecx, ptr[edx + esi * 4 - 1000]);
            mov(ecx, ptr[edx + esi * 8 + 0]);
            mov(ecx, ptr[edx + esi * 8 + 1]);
            mov(ecx, ptr[edx + esi * 8 + 1000]);
            mov(ecx, ptr[edx + esi * 8 - 1]);
            mov(ecx, ptr[edx + esi * 8 - 1000]);
            mov(ecx, ptr[edx + edi + 0]);
            mov(ecx, ptr[edx + edi + 1]);
            mov(ecx, ptr[edx + edi + 1000]);
            mov(ecx, ptr[edx + edi - 1]);
            mov(ecx, ptr[edx + edi - 1000]);
            mov(ecx, ptr[edx + edi * 1 + 0]);
            mov(ecx, ptr[edx + edi * 1 + 1]);
            mov(ecx, ptr[edx + edi * 1 + 1000]);
            mov(ecx, ptr[edx + edi * 1 - 1]);
            mov(ecx, ptr[edx + edi * 1 - 1000]);
            mov(ecx, ptr[edx + edi * 2 + 0]);
            mov(ecx, ptr[edx + edi * 2 + 1]);
            mov(ecx, ptr[edx + edi * 2 + 1000]);
            mov(ecx, ptr[edx + edi * 2 - 1]);
            mov(ecx, ptr[edx + edi * 2 - 1000]);
            mov(ecx, ptr[edx + edi * 4 + 0]);
            mov(ecx, ptr[edx + edi * 4 + 1]);
            mov(ecx, ptr[edx + edi * 4 + 1000]);
            mov(ecx, ptr[edx + edi * 4 - 1]);
            mov(ecx, ptr[edx + edi * 4 - 1000]);
            mov(ecx, ptr[edx + edi * 8 + 0]);
            mov(ecx, ptr[edx + edi * 8 + 1]);
            mov(ecx, ptr[edx + edi * 8 + 1000]);
            mov(ecx, ptr[edx + edi * 8 - 1]);
            mov(ecx, ptr[edx + edi * 8 - 1000]);
            mov(ecx, ptr[edx + r9d + 0]);
            mov(ecx, ptr[edx + r9d + 1]);
            mov(ecx, ptr[edx + r9d + 1000]);
            mov(ecx, ptr[edx + r9d - 1]);
            mov(ecx, ptr[edx + r9d - 1000]);
            mov(ecx, ptr[edx + r9d * 1 + 0]);
            mov(ecx, ptr[edx + r9d * 1 + 1]);
            mov(ecx, ptr[edx + r9d * 1 + 1000]);
            mov(ecx, ptr[edx + r9d * 1 - 1]);
            mov(ecx, ptr[edx + r9d * 1 - 1000]);
            mov(ecx, ptr[edx + r9d * 2 + 0]);
            mov(ecx, ptr[edx + r9d * 2 + 1]);
            mov(ecx, ptr[edx + r9d * 2 + 1000]);
            mov(ecx, ptr[edx + r9d * 2 - 1]);
            mov(ecx, ptr[edx + r9d * 2 - 1000]);
            mov(ecx, ptr[edx + r9d * 4 + 0]);
            mov(ecx, ptr[edx + r9d * 4 + 1]);
            mov(ecx, ptr[edx + r9d * 4 + 1000]);
            mov(ecx, ptr[edx + r9d * 4 - 1]);
            mov(ecx, ptr[edx + r9d * 4 - 1000]);
            mov(ecx, ptr[edx + r9d * 8 + 0]);
            mov(ecx, ptr[edx + r9d * 8 + 1]);
            mov(ecx, ptr[edx + r9d * 8 + 1000]);
            mov(ecx, ptr[edx + r9d * 8 - 1]);
            mov(ecx, ptr[edx + r9d * 8 - 1000]);
        }
    }

    class gen9 : CodeGenerator {
        this()
        {
            mov(ecx, ptr[edx + r10d + 0]);
            mov(ecx, ptr[edx + r10d + 1]);
            mov(ecx, ptr[edx + r10d + 1000]);
            mov(ecx, ptr[edx + r10d - 1]);
            mov(ecx, ptr[edx + r10d - 1000]);
            mov(ecx, ptr[edx + r10d * 1 + 0]);
            mov(ecx, ptr[edx + r10d * 1 + 1]);
            mov(ecx, ptr[edx + r10d * 1 + 1000]);
            mov(ecx, ptr[edx + r10d * 1 - 1]);
            mov(ecx, ptr[edx + r10d * 1 - 1000]);
            mov(ecx, ptr[edx + r10d * 2 + 0]);
            mov(ecx, ptr[edx + r10d * 2 + 1]);
            mov(ecx, ptr[edx + r10d * 2 + 1000]);
            mov(ecx, ptr[edx + r10d * 2 - 1]);
            mov(ecx, ptr[edx + r10d * 2 - 1000]);
            mov(ecx, ptr[edx + r10d * 4 + 0]);
            mov(ecx, ptr[edx + r10d * 4 + 1]);
            mov(ecx, ptr[edx + r10d * 4 + 1000]);
            mov(ecx, ptr[edx + r10d * 4 - 1]);
            mov(ecx, ptr[edx + r10d * 4 - 1000]);
            mov(ecx, ptr[edx + r10d * 8 + 0]);
            mov(ecx, ptr[edx + r10d * 8 + 1]);
            mov(ecx, ptr[edx + r10d * 8 + 1000]);
            mov(ecx, ptr[edx + r10d * 8 - 1]);
            mov(ecx, ptr[edx + r10d * 8 - 1000]);
            mov(ecx, ptr[edx + r11d + 0]);
            mov(ecx, ptr[edx + r11d + 1]);
            mov(ecx, ptr[edx + r11d + 1000]);
            mov(ecx, ptr[edx + r11d - 1]);
            mov(ecx, ptr[edx + r11d - 1000]);
            mov(ecx, ptr[edx + r11d * 1 + 0]);
            mov(ecx, ptr[edx + r11d * 1 + 1]);
            mov(ecx, ptr[edx + r11d * 1 + 1000]);
            mov(ecx, ptr[edx + r11d * 1 - 1]);
            mov(ecx, ptr[edx + r11d * 1 - 1000]);
            mov(ecx, ptr[edx + r11d * 2 + 0]);
            mov(ecx, ptr[edx + r11d * 2 + 1]);
            mov(ecx, ptr[edx + r11d * 2 + 1000]);
            mov(ecx, ptr[edx + r11d * 2 - 1]);
            mov(ecx, ptr[edx + r11d * 2 - 1000]);
            mov(ecx, ptr[edx + r11d * 4 + 0]);
            mov(ecx, ptr[edx + r11d * 4 + 1]);
            mov(ecx, ptr[edx + r11d * 4 + 1000]);
            mov(ecx, ptr[edx + r11d * 4 - 1]);
            mov(ecx, ptr[edx + r11d * 4 - 1000]);
            mov(ecx, ptr[edx + r11d * 8 + 0]);
            mov(ecx, ptr[edx + r11d * 8 + 1]);
            mov(ecx, ptr[edx + r11d * 8 + 1000]);
            mov(ecx, ptr[edx + r11d * 8 - 1]);
            mov(ecx, ptr[edx + r11d * 8 - 1000]);
            mov(ecx, ptr[edx + r12d + 0]);
            mov(ecx, ptr[edx + r12d + 1]);
            mov(ecx, ptr[edx + r12d + 1000]);
            mov(ecx, ptr[edx + r12d - 1]);
            mov(ecx, ptr[edx + r12d - 1000]);
            mov(ecx, ptr[edx + r12d * 1 + 0]);
            mov(ecx, ptr[edx + r12d * 1 + 1]);
            mov(ecx, ptr[edx + r12d * 1 + 1000]);
            mov(ecx, ptr[edx + r12d * 1 - 1]);
            mov(ecx, ptr[edx + r12d * 1 - 1000]);
            mov(ecx, ptr[edx + r12d * 2 + 0]);
            mov(ecx, ptr[edx + r12d * 2 + 1]);
            mov(ecx, ptr[edx + r12d * 2 + 1000]);
            mov(ecx, ptr[edx + r12d * 2 - 1]);
            mov(ecx, ptr[edx + r12d * 2 - 1000]);
            mov(ecx, ptr[edx + r12d * 4 + 0]);
            mov(ecx, ptr[edx + r12d * 4 + 1]);
            mov(ecx, ptr[edx + r12d * 4 + 1000]);
            mov(ecx, ptr[edx + r12d * 4 - 1]);
            mov(ecx, ptr[edx + r12d * 4 - 1000]);
            mov(ecx, ptr[edx + r12d * 8 + 0]);
            mov(ecx, ptr[edx + r12d * 8 + 1]);
            mov(ecx, ptr[edx + r12d * 8 + 1000]);
            mov(ecx, ptr[edx + r12d * 8 - 1]);
            mov(ecx, ptr[edx + r12d * 8 - 1000]);
            mov(ecx, ptr[edx + r13d + 0]);
            mov(ecx, ptr[edx + r13d + 1]);
            mov(ecx, ptr[edx + r13d + 1000]);
            mov(ecx, ptr[edx + r13d - 1]);
            mov(ecx, ptr[edx + r13d - 1000]);
            mov(ecx, ptr[edx + r13d * 1 + 0]);
            mov(ecx, ptr[edx + r13d * 1 + 1]);
            mov(ecx, ptr[edx + r13d * 1 + 1000]);
            mov(ecx, ptr[edx + r13d * 1 - 1]);
            mov(ecx, ptr[edx + r13d * 1 - 1000]);
            mov(ecx, ptr[edx + r13d * 2 + 0]);
            mov(ecx, ptr[edx + r13d * 2 + 1]);
            mov(ecx, ptr[edx + r13d * 2 + 1000]);
            mov(ecx, ptr[edx + r13d * 2 - 1]);
            mov(ecx, ptr[edx + r13d * 2 - 1000]);
            mov(ecx, ptr[edx + r13d * 4 + 0]);
            mov(ecx, ptr[edx + r13d * 4 + 1]);
            mov(ecx, ptr[edx + r13d * 4 + 1000]);
            mov(ecx, ptr[edx + r13d * 4 - 1]);
            mov(ecx, ptr[edx + r13d * 4 - 1000]);
            mov(ecx, ptr[edx + r13d * 8 + 0]);
            mov(ecx, ptr[edx + r13d * 8 + 1]);
            mov(ecx, ptr[edx + r13d * 8 + 1000]);
            mov(ecx, ptr[edx + r13d * 8 - 1]);
            mov(ecx, ptr[edx + r13d * 8 - 1000]);
        }
    }

    class gen10 : CodeGenerator {
        this()
        {
            mov(ecx, ptr[edx + r14d + 0]);
            mov(ecx, ptr[edx + r14d + 1]);
            mov(ecx, ptr[edx + r14d + 1000]);
            mov(ecx, ptr[edx + r14d - 1]);
            mov(ecx, ptr[edx + r14d - 1000]);
            mov(ecx, ptr[edx + r14d * 1 + 0]);
            mov(ecx, ptr[edx + r14d * 1 + 1]);
            mov(ecx, ptr[edx + r14d * 1 + 1000]);
            mov(ecx, ptr[edx + r14d * 1 - 1]);
            mov(ecx, ptr[edx + r14d * 1 - 1000]);
            mov(ecx, ptr[edx + r14d * 2 + 0]);
            mov(ecx, ptr[edx + r14d * 2 + 1]);
            mov(ecx, ptr[edx + r14d * 2 + 1000]);
            mov(ecx, ptr[edx + r14d * 2 - 1]);
            mov(ecx, ptr[edx + r14d * 2 - 1000]);
            mov(ecx, ptr[edx + r14d * 4 + 0]);
            mov(ecx, ptr[edx + r14d * 4 + 1]);
            mov(ecx, ptr[edx + r14d * 4 + 1000]);
            mov(ecx, ptr[edx + r14d * 4 - 1]);
            mov(ecx, ptr[edx + r14d * 4 - 1000]);
            mov(ecx, ptr[edx + r14d * 8 + 0]);
            mov(ecx, ptr[edx + r14d * 8 + 1]);
            mov(ecx, ptr[edx + r14d * 8 + 1000]);
            mov(ecx, ptr[edx + r14d * 8 - 1]);
            mov(ecx, ptr[edx + r14d * 8 - 1000]);
            mov(ecx, ptr[edx + r15d + 0]);
            mov(ecx, ptr[edx + r15d + 1]);
            mov(ecx, ptr[edx + r15d + 1000]);
            mov(ecx, ptr[edx + r15d - 1]);
            mov(ecx, ptr[edx + r15d - 1000]);
            mov(ecx, ptr[edx + r15d * 1 + 0]);
            mov(ecx, ptr[edx + r15d * 1 + 1]);
            mov(ecx, ptr[edx + r15d * 1 + 1000]);
            mov(ecx, ptr[edx + r15d * 1 - 1]);
            mov(ecx, ptr[edx + r15d * 1 - 1000]);
            mov(ecx, ptr[edx + r15d * 2 + 0]);
            mov(ecx, ptr[edx + r15d * 2 + 1]);
            mov(ecx, ptr[edx + r15d * 2 + 1000]);
            mov(ecx, ptr[edx + r15d * 2 - 1]);
            mov(ecx, ptr[edx + r15d * 2 - 1000]);
            mov(ecx, ptr[edx + r15d * 4 + 0]);
            mov(ecx, ptr[edx + r15d * 4 + 1]);
            mov(ecx, ptr[edx + r15d * 4 + 1000]);
            mov(ecx, ptr[edx + r15d * 4 - 1]);
            mov(ecx, ptr[edx + r15d * 4 - 1000]);
            mov(ecx, ptr[edx + r15d * 8 + 0]);
            mov(ecx, ptr[edx + r15d * 8 + 1]);
            mov(ecx, ptr[edx + r15d * 8 + 1000]);
            mov(ecx, ptr[edx + r15d * 8 - 1]);
            mov(ecx, ptr[edx + r15d * 8 - 1000]);
            mov(ecx, ptr[ebx + eax + 0]);
            mov(ecx, ptr[ebx + eax + 1]);
            mov(ecx, ptr[ebx + eax + 1000]);
            mov(ecx, ptr[ebx + eax - 1]);
            mov(ecx, ptr[ebx + eax - 1000]);
            mov(ecx, ptr[ebx + eax * 1 + 0]);
            mov(ecx, ptr[ebx + eax * 1 + 1]);
            mov(ecx, ptr[ebx + eax * 1 + 1000]);
            mov(ecx, ptr[ebx + eax * 1 - 1]);
            mov(ecx, ptr[ebx + eax * 1 - 1000]);
            mov(ecx, ptr[ebx + eax * 2 + 0]);
            mov(ecx, ptr[ebx + eax * 2 + 1]);
            mov(ecx, ptr[ebx + eax * 2 + 1000]);
            mov(ecx, ptr[ebx + eax * 2 - 1]);
            mov(ecx, ptr[ebx + eax * 2 - 1000]);
            mov(ecx, ptr[ebx + eax * 4 + 0]);
            mov(ecx, ptr[ebx + eax * 4 + 1]);
            mov(ecx, ptr[ebx + eax * 4 + 1000]);
            mov(ecx, ptr[ebx + eax * 4 - 1]);
            mov(ecx, ptr[ebx + eax * 4 - 1000]);
            mov(ecx, ptr[ebx + eax * 8 + 0]);
            mov(ecx, ptr[ebx + eax * 8 + 1]);
            mov(ecx, ptr[ebx + eax * 8 + 1000]);
            mov(ecx, ptr[ebx + eax * 8 - 1]);
            mov(ecx, ptr[ebx + eax * 8 - 1000]);
            mov(ecx, ptr[ebx + ecx + 0]);
            mov(ecx, ptr[ebx + ecx + 1]);
            mov(ecx, ptr[ebx + ecx + 1000]);
            mov(ecx, ptr[ebx + ecx - 1]);
            mov(ecx, ptr[ebx + ecx - 1000]);
            mov(ecx, ptr[ebx + ecx * 1 + 0]);
            mov(ecx, ptr[ebx + ecx * 1 + 1]);
            mov(ecx, ptr[ebx + ecx * 1 + 1000]);
            mov(ecx, ptr[ebx + ecx * 1 - 1]);
            mov(ecx, ptr[ebx + ecx * 1 - 1000]);
            mov(ecx, ptr[ebx + ecx * 2 + 0]);
            mov(ecx, ptr[ebx + ecx * 2 + 1]);
            mov(ecx, ptr[ebx + ecx * 2 + 1000]);
            mov(ecx, ptr[ebx + ecx * 2 - 1]);
            mov(ecx, ptr[ebx + ecx * 2 - 1000]);
            mov(ecx, ptr[ebx + ecx * 4 + 0]);
            mov(ecx, ptr[ebx + ecx * 4 + 1]);
            mov(ecx, ptr[ebx + ecx * 4 + 1000]);
            mov(ecx, ptr[ebx + ecx * 4 - 1]);
            mov(ecx, ptr[ebx + ecx * 4 - 1000]);
            mov(ecx, ptr[ebx + ecx * 8 + 0]);
            mov(ecx, ptr[ebx + ecx * 8 + 1]);
            mov(ecx, ptr[ebx + ecx * 8 + 1000]);
            mov(ecx, ptr[ebx + ecx * 8 - 1]);
            mov(ecx, ptr[ebx + ecx * 8 - 1000]);
        }
    }

    class gen11 : CodeGenerator {
        this()
        {
            mov(ecx, ptr[ebx + edx + 0]);
            mov(ecx, ptr[ebx + edx + 1]);
            mov(ecx, ptr[ebx + edx + 1000]);
            mov(ecx, ptr[ebx + edx - 1]);
            mov(ecx, ptr[ebx + edx - 1000]);
            mov(ecx, ptr[ebx + edx * 1 + 0]);
            mov(ecx, ptr[ebx + edx * 1 + 1]);
            mov(ecx, ptr[ebx + edx * 1 + 1000]);
            mov(ecx, ptr[ebx + edx * 1 - 1]);
            mov(ecx, ptr[ebx + edx * 1 - 1000]);
            mov(ecx, ptr[ebx + edx * 2 + 0]);
            mov(ecx, ptr[ebx + edx * 2 + 1]);
            mov(ecx, ptr[ebx + edx * 2 + 1000]);
            mov(ecx, ptr[ebx + edx * 2 - 1]);
            mov(ecx, ptr[ebx + edx * 2 - 1000]);
            mov(ecx, ptr[ebx + edx * 4 + 0]);
            mov(ecx, ptr[ebx + edx * 4 + 1]);
            mov(ecx, ptr[ebx + edx * 4 + 1000]);
            mov(ecx, ptr[ebx + edx * 4 - 1]);
            mov(ecx, ptr[ebx + edx * 4 - 1000]);
            mov(ecx, ptr[ebx + edx * 8 + 0]);
            mov(ecx, ptr[ebx + edx * 8 + 1]);
            mov(ecx, ptr[ebx + edx * 8 + 1000]);
            mov(ecx, ptr[ebx + edx * 8 - 1]);
            mov(ecx, ptr[ebx + edx * 8 - 1000]);
            mov(ecx, ptr[ebx + ebx + 0]);
            mov(ecx, ptr[ebx + ebx + 1]);
            mov(ecx, ptr[ebx + ebx + 1000]);
            mov(ecx, ptr[ebx + ebx - 1]);
            mov(ecx, ptr[ebx + ebx - 1000]);
            mov(ecx, ptr[ebx + ebx * 1 + 0]);
            mov(ecx, ptr[ebx + ebx * 1 + 1]);
            mov(ecx, ptr[ebx + ebx * 1 + 1000]);
            mov(ecx, ptr[ebx + ebx * 1 - 1]);
            mov(ecx, ptr[ebx + ebx * 1 - 1000]);
            mov(ecx, ptr[ebx + ebx * 2 + 0]);
            mov(ecx, ptr[ebx + ebx * 2 + 1]);
            mov(ecx, ptr[ebx + ebx * 2 + 1000]);
            mov(ecx, ptr[ebx + ebx * 2 - 1]);
            mov(ecx, ptr[ebx + ebx * 2 - 1000]);
            mov(ecx, ptr[ebx + ebx * 4 + 0]);
            mov(ecx, ptr[ebx + ebx * 4 + 1]);
            mov(ecx, ptr[ebx + ebx * 4 + 1000]);
            mov(ecx, ptr[ebx + ebx * 4 - 1]);
            mov(ecx, ptr[ebx + ebx * 4 - 1000]);
            mov(ecx, ptr[ebx + ebx * 8 + 0]);
            mov(ecx, ptr[ebx + ebx * 8 + 1]);
            mov(ecx, ptr[ebx + ebx * 8 + 1000]);
            mov(ecx, ptr[ebx + ebx * 8 - 1]);
            mov(ecx, ptr[ebx + ebx * 8 - 1000]);
            mov(ecx, ptr[ebx + ebp + 0]);
            mov(ecx, ptr[ebx + ebp + 1]);
            mov(ecx, ptr[ebx + ebp + 1000]);
            mov(ecx, ptr[ebx + ebp - 1]);
            mov(ecx, ptr[ebx + ebp - 1000]);
            mov(ecx, ptr[ebx + ebp * 1 + 0]);
            mov(ecx, ptr[ebx + ebp * 1 + 1]);
            mov(ecx, ptr[ebx + ebp * 1 + 1000]);
            mov(ecx, ptr[ebx + ebp * 1 - 1]);
            mov(ecx, ptr[ebx + ebp * 1 - 1000]);
            mov(ecx, ptr[ebx + ebp * 2 + 0]);
            mov(ecx, ptr[ebx + ebp * 2 + 1]);
            mov(ecx, ptr[ebx + ebp * 2 + 1000]);
            mov(ecx, ptr[ebx + ebp * 2 - 1]);
            mov(ecx, ptr[ebx + ebp * 2 - 1000]);
            mov(ecx, ptr[ebx + ebp * 4 + 0]);
            mov(ecx, ptr[ebx + ebp * 4 + 1]);
            mov(ecx, ptr[ebx + ebp * 4 + 1000]);
            mov(ecx, ptr[ebx + ebp * 4 - 1]);
            mov(ecx, ptr[ebx + ebp * 4 - 1000]);
            mov(ecx, ptr[ebx + ebp * 8 + 0]);
            mov(ecx, ptr[ebx + ebp * 8 + 1]);
            mov(ecx, ptr[ebx + ebp * 8 + 1000]);
            mov(ecx, ptr[ebx + ebp * 8 - 1]);
            mov(ecx, ptr[ebx + ebp * 8 - 1000]);
            mov(ecx, ptr[ebx + esi + 0]);
            mov(ecx, ptr[ebx + esi + 1]);
            mov(ecx, ptr[ebx + esi + 1000]);
            mov(ecx, ptr[ebx + esi - 1]);
            mov(ecx, ptr[ebx + esi - 1000]);
            mov(ecx, ptr[ebx + esi * 1 + 0]);
            mov(ecx, ptr[ebx + esi * 1 + 1]);
            mov(ecx, ptr[ebx + esi * 1 + 1000]);
            mov(ecx, ptr[ebx + esi * 1 - 1]);
            mov(ecx, ptr[ebx + esi * 1 - 1000]);
            mov(ecx, ptr[ebx + esi * 2 + 0]);
            mov(ecx, ptr[ebx + esi * 2 + 1]);
            mov(ecx, ptr[ebx + esi * 2 + 1000]);
            mov(ecx, ptr[ebx + esi * 2 - 1]);
            mov(ecx, ptr[ebx + esi * 2 - 1000]);
            mov(ecx, ptr[ebx + esi * 4 + 0]);
            mov(ecx, ptr[ebx + esi * 4 + 1]);
            mov(ecx, ptr[ebx + esi * 4 + 1000]);
            mov(ecx, ptr[ebx + esi * 4 - 1]);
            mov(ecx, ptr[ebx + esi * 4 - 1000]);
            mov(ecx, ptr[ebx + esi * 8 + 0]);
            mov(ecx, ptr[ebx + esi * 8 + 1]);
            mov(ecx, ptr[ebx + esi * 8 + 1000]);
            mov(ecx, ptr[ebx + esi * 8 - 1]);
            mov(ecx, ptr[ebx + esi * 8 - 1000]);
        }
    }

    class gen12 : CodeGenerator {
        this()
        {
            mov(ecx, ptr[ebx + edi + 0]);
            mov(ecx, ptr[ebx + edi + 1]);
            mov(ecx, ptr[ebx + edi + 1000]);
            mov(ecx, ptr[ebx + edi - 1]);
            mov(ecx, ptr[ebx + edi - 1000]);
            mov(ecx, ptr[ebx + edi * 1 + 0]);
            mov(ecx, ptr[ebx + edi * 1 + 1]);
            mov(ecx, ptr[ebx + edi * 1 + 1000]);
            mov(ecx, ptr[ebx + edi * 1 - 1]);
            mov(ecx, ptr[ebx + edi * 1 - 1000]);
            mov(ecx, ptr[ebx + edi * 2 + 0]);
            mov(ecx, ptr[ebx + edi * 2 + 1]);
            mov(ecx, ptr[ebx + edi * 2 + 1000]);
            mov(ecx, ptr[ebx + edi * 2 - 1]);
            mov(ecx, ptr[ebx + edi * 2 - 1000]);
            mov(ecx, ptr[ebx + edi * 4 + 0]);
            mov(ecx, ptr[ebx + edi * 4 + 1]);
            mov(ecx, ptr[ebx + edi * 4 + 1000]);
            mov(ecx, ptr[ebx + edi * 4 - 1]);
            mov(ecx, ptr[ebx + edi * 4 - 1000]);
            mov(ecx, ptr[ebx + edi * 8 + 0]);
            mov(ecx, ptr[ebx + edi * 8 + 1]);
            mov(ecx, ptr[ebx + edi * 8 + 1000]);
            mov(ecx, ptr[ebx + edi * 8 - 1]);
            mov(ecx, ptr[ebx + edi * 8 - 1000]);
            mov(ecx, ptr[ebx + r9d + 0]);
            mov(ecx, ptr[ebx + r9d + 1]);
            mov(ecx, ptr[ebx + r9d + 1000]);
            mov(ecx, ptr[ebx + r9d - 1]);
            mov(ecx, ptr[ebx + r9d - 1000]);
            mov(ecx, ptr[ebx + r9d * 1 + 0]);
            mov(ecx, ptr[ebx + r9d * 1 + 1]);
            mov(ecx, ptr[ebx + r9d * 1 + 1000]);
            mov(ecx, ptr[ebx + r9d * 1 - 1]);
            mov(ecx, ptr[ebx + r9d * 1 - 1000]);
            mov(ecx, ptr[ebx + r9d * 2 + 0]);
            mov(ecx, ptr[ebx + r9d * 2 + 1]);
            mov(ecx, ptr[ebx + r9d * 2 + 1000]);
            mov(ecx, ptr[ebx + r9d * 2 - 1]);
            mov(ecx, ptr[ebx + r9d * 2 - 1000]);
            mov(ecx, ptr[ebx + r9d * 4 + 0]);
            mov(ecx, ptr[ebx + r9d * 4 + 1]);
            mov(ecx, ptr[ebx + r9d * 4 + 1000]);
            mov(ecx, ptr[ebx + r9d * 4 - 1]);
            mov(ecx, ptr[ebx + r9d * 4 - 1000]);
            mov(ecx, ptr[ebx + r9d * 8 + 0]);
            mov(ecx, ptr[ebx + r9d * 8 + 1]);
            mov(ecx, ptr[ebx + r9d * 8 + 1000]);
            mov(ecx, ptr[ebx + r9d * 8 - 1]);
            mov(ecx, ptr[ebx + r9d * 8 - 1000]);
            mov(ecx, ptr[ebx + r10d + 0]);
            mov(ecx, ptr[ebx + r10d + 1]);
            mov(ecx, ptr[ebx + r10d + 1000]);
            mov(ecx, ptr[ebx + r10d - 1]);
            mov(ecx, ptr[ebx + r10d - 1000]);
            mov(ecx, ptr[ebx + r10d * 1 + 0]);
            mov(ecx, ptr[ebx + r10d * 1 + 1]);
            mov(ecx, ptr[ebx + r10d * 1 + 1000]);
            mov(ecx, ptr[ebx + r10d * 1 - 1]);
            mov(ecx, ptr[ebx + r10d * 1 - 1000]);
            mov(ecx, ptr[ebx + r10d * 2 + 0]);
            mov(ecx, ptr[ebx + r10d * 2 + 1]);
            mov(ecx, ptr[ebx + r10d * 2 + 1000]);
            mov(ecx, ptr[ebx + r10d * 2 - 1]);
            mov(ecx, ptr[ebx + r10d * 2 - 1000]);
            mov(ecx, ptr[ebx + r10d * 4 + 0]);
            mov(ecx, ptr[ebx + r10d * 4 + 1]);
            mov(ecx, ptr[ebx + r10d * 4 + 1000]);
            mov(ecx, ptr[ebx + r10d * 4 - 1]);
            mov(ecx, ptr[ebx + r10d * 4 - 1000]);
            mov(ecx, ptr[ebx + r10d * 8 + 0]);
            mov(ecx, ptr[ebx + r10d * 8 + 1]);
            mov(ecx, ptr[ebx + r10d * 8 + 1000]);
            mov(ecx, ptr[ebx + r10d * 8 - 1]);
            mov(ecx, ptr[ebx + r10d * 8 - 1000]);
            mov(ecx, ptr[ebx + r11d + 0]);
            mov(ecx, ptr[ebx + r11d + 1]);
            mov(ecx, ptr[ebx + r11d + 1000]);
            mov(ecx, ptr[ebx + r11d - 1]);
            mov(ecx, ptr[ebx + r11d - 1000]);
            mov(ecx, ptr[ebx + r11d * 1 + 0]);
            mov(ecx, ptr[ebx + r11d * 1 + 1]);
            mov(ecx, ptr[ebx + r11d * 1 + 1000]);
            mov(ecx, ptr[ebx + r11d * 1 - 1]);
            mov(ecx, ptr[ebx + r11d * 1 - 1000]);
            mov(ecx, ptr[ebx + r11d * 2 + 0]);
            mov(ecx, ptr[ebx + r11d * 2 + 1]);
            mov(ecx, ptr[ebx + r11d * 2 + 1000]);
            mov(ecx, ptr[ebx + r11d * 2 - 1]);
            mov(ecx, ptr[ebx + r11d * 2 - 1000]);
            mov(ecx, ptr[ebx + r11d * 4 + 0]);
            mov(ecx, ptr[ebx + r11d * 4 + 1]);
            mov(ecx, ptr[ebx + r11d * 4 + 1000]);
            mov(ecx, ptr[ebx + r11d * 4 - 1]);
            mov(ecx, ptr[ebx + r11d * 4 - 1000]);
            mov(ecx, ptr[ebx + r11d * 8 + 0]);
            mov(ecx, ptr[ebx + r11d * 8 + 1]);
            mov(ecx, ptr[ebx + r11d * 8 + 1000]);
            mov(ecx, ptr[ebx + r11d * 8 - 1]);
            mov(ecx, ptr[ebx + r11d * 8 - 1000]);
        }
    }

    class gen13 : CodeGenerator {
        this()
        {
            mov(ecx, ptr[ebx + r12d + 0]);
            mov(ecx, ptr[ebx + r12d + 1]);
            mov(ecx, ptr[ebx + r12d + 1000]);
            mov(ecx, ptr[ebx + r12d - 1]);
            mov(ecx, ptr[ebx + r12d - 1000]);
            mov(ecx, ptr[ebx + r12d * 1 + 0]);
            mov(ecx, ptr[ebx + r12d * 1 + 1]);
            mov(ecx, ptr[ebx + r12d * 1 + 1000]);
            mov(ecx, ptr[ebx + r12d * 1 - 1]);
            mov(ecx, ptr[ebx + r12d * 1 - 1000]);
            mov(ecx, ptr[ebx + r12d * 2 + 0]);
            mov(ecx, ptr[ebx + r12d * 2 + 1]);
            mov(ecx, ptr[ebx + r12d * 2 + 1000]);
            mov(ecx, ptr[ebx + r12d * 2 - 1]);
            mov(ecx, ptr[ebx + r12d * 2 - 1000]);
            mov(ecx, ptr[ebx + r12d * 4 + 0]);
            mov(ecx, ptr[ebx + r12d * 4 + 1]);
            mov(ecx, ptr[ebx + r12d * 4 + 1000]);
            mov(ecx, ptr[ebx + r12d * 4 - 1]);
            mov(ecx, ptr[ebx + r12d * 4 - 1000]);
            mov(ecx, ptr[ebx + r12d * 8 + 0]);
            mov(ecx, ptr[ebx + r12d * 8 + 1]);
            mov(ecx, ptr[ebx + r12d * 8 + 1000]);
            mov(ecx, ptr[ebx + r12d * 8 - 1]);
            mov(ecx, ptr[ebx + r12d * 8 - 1000]);
            mov(ecx, ptr[ebx + r13d + 0]);
            mov(ecx, ptr[ebx + r13d + 1]);
            mov(ecx, ptr[ebx + r13d + 1000]);
            mov(ecx, ptr[ebx + r13d - 1]);
            mov(ecx, ptr[ebx + r13d - 1000]);
            mov(ecx, ptr[ebx + r13d * 1 + 0]);
            mov(ecx, ptr[ebx + r13d * 1 + 1]);
            mov(ecx, ptr[ebx + r13d * 1 + 1000]);
            mov(ecx, ptr[ebx + r13d * 1 - 1]);
            mov(ecx, ptr[ebx + r13d * 1 - 1000]);
            mov(ecx, ptr[ebx + r13d * 2 + 0]);
            mov(ecx, ptr[ebx + r13d * 2 + 1]);
            mov(ecx, ptr[ebx + r13d * 2 + 1000]);
            mov(ecx, ptr[ebx + r13d * 2 - 1]);
            mov(ecx, ptr[ebx + r13d * 2 - 1000]);
            mov(ecx, ptr[ebx + r13d * 4 + 0]);
            mov(ecx, ptr[ebx + r13d * 4 + 1]);
            mov(ecx, ptr[ebx + r13d * 4 + 1000]);
            mov(ecx, ptr[ebx + r13d * 4 - 1]);
            mov(ecx, ptr[ebx + r13d * 4 - 1000]);
            mov(ecx, ptr[ebx + r13d * 8 + 0]);
            mov(ecx, ptr[ebx + r13d * 8 + 1]);
            mov(ecx, ptr[ebx + r13d * 8 + 1000]);
            mov(ecx, ptr[ebx + r13d * 8 - 1]);
            mov(ecx, ptr[ebx + r13d * 8 - 1000]);
            mov(ecx, ptr[ebx + r14d + 0]);
            mov(ecx, ptr[ebx + r14d + 1]);
            mov(ecx, ptr[ebx + r14d + 1000]);
            mov(ecx, ptr[ebx + r14d - 1]);
            mov(ecx, ptr[ebx + r14d - 1000]);
            mov(ecx, ptr[ebx + r14d * 1 + 0]);
            mov(ecx, ptr[ebx + r14d * 1 + 1]);
            mov(ecx, ptr[ebx + r14d * 1 + 1000]);
            mov(ecx, ptr[ebx + r14d * 1 - 1]);
            mov(ecx, ptr[ebx + r14d * 1 - 1000]);
            mov(ecx, ptr[ebx + r14d * 2 + 0]);
            mov(ecx, ptr[ebx + r14d * 2 + 1]);
            mov(ecx, ptr[ebx + r14d * 2 + 1000]);
            mov(ecx, ptr[ebx + r14d * 2 - 1]);
            mov(ecx, ptr[ebx + r14d * 2 - 1000]);
            mov(ecx, ptr[ebx + r14d * 4 + 0]);
            mov(ecx, ptr[ebx + r14d * 4 + 1]);
            mov(ecx, ptr[ebx + r14d * 4 + 1000]);
            mov(ecx, ptr[ebx + r14d * 4 - 1]);
            mov(ecx, ptr[ebx + r14d * 4 - 1000]);
            mov(ecx, ptr[ebx + r14d * 8 + 0]);
            mov(ecx, ptr[ebx + r14d * 8 + 1]);
            mov(ecx, ptr[ebx + r14d * 8 + 1000]);
            mov(ecx, ptr[ebx + r14d * 8 - 1]);
            mov(ecx, ptr[ebx + r14d * 8 - 1000]);
            mov(ecx, ptr[ebx + r15d + 0]);
            mov(ecx, ptr[ebx + r15d + 1]);
            mov(ecx, ptr[ebx + r15d + 1000]);
            mov(ecx, ptr[ebx + r15d - 1]);
            mov(ecx, ptr[ebx + r15d - 1000]);
            mov(ecx, ptr[ebx + r15d * 1 + 0]);
            mov(ecx, ptr[ebx + r15d * 1 + 1]);
            mov(ecx, ptr[ebx + r15d * 1 + 1000]);
            mov(ecx, ptr[ebx + r15d * 1 - 1]);
            mov(ecx, ptr[ebx + r15d * 1 - 1000]);
            mov(ecx, ptr[ebx + r15d * 2 + 0]);
            mov(ecx, ptr[ebx + r15d * 2 + 1]);
            mov(ecx, ptr[ebx + r15d * 2 + 1000]);
            mov(ecx, ptr[ebx + r15d * 2 - 1]);
            mov(ecx, ptr[ebx + r15d * 2 - 1000]);
            mov(ecx, ptr[ebx + r15d * 4 + 0]);
            mov(ecx, ptr[ebx + r15d * 4 + 1]);
            mov(ecx, ptr[ebx + r15d * 4 + 1000]);
            mov(ecx, ptr[ebx + r15d * 4 - 1]);
            mov(ecx, ptr[ebx + r15d * 4 - 1000]);
            mov(ecx, ptr[ebx + r15d * 8 + 0]);
            mov(ecx, ptr[ebx + r15d * 8 + 1]);
            mov(ecx, ptr[ebx + r15d * 8 + 1000]);
            mov(ecx, ptr[ebx + r15d * 8 - 1]);
            mov(ecx, ptr[ebx + r15d * 8 - 1000]);
        }
    }

    class gen14 : CodeGenerator {
        this()
        {
            mov(ecx, ptr[esp + eax + 0]);
            mov(ecx, ptr[esp + eax + 1]);
            mov(ecx, ptr[esp + eax + 1000]);
            mov(ecx, ptr[esp + eax - 1]);
            mov(ecx, ptr[esp + eax - 1000]);
            mov(ecx, ptr[esp + eax * 1 + 0]);
            mov(ecx, ptr[esp + eax * 1 + 1]);
            mov(ecx, ptr[esp + eax * 1 + 1000]);
            mov(ecx, ptr[esp + eax * 1 - 1]);
            mov(ecx, ptr[esp + eax * 1 - 1000]);
            mov(ecx, ptr[esp + eax * 2 + 0]);
            mov(ecx, ptr[esp + eax * 2 + 1]);
            mov(ecx, ptr[esp + eax * 2 + 1000]);
            mov(ecx, ptr[esp + eax * 2 - 1]);
            mov(ecx, ptr[esp + eax * 2 - 1000]);
            mov(ecx, ptr[esp + eax * 4 + 0]);
            mov(ecx, ptr[esp + eax * 4 + 1]);
            mov(ecx, ptr[esp + eax * 4 + 1000]);
            mov(ecx, ptr[esp + eax * 4 - 1]);
            mov(ecx, ptr[esp + eax * 4 - 1000]);
            mov(ecx, ptr[esp + eax * 8 + 0]);
            mov(ecx, ptr[esp + eax * 8 + 1]);
            mov(ecx, ptr[esp + eax * 8 + 1000]);
            mov(ecx, ptr[esp + eax * 8 - 1]);
            mov(ecx, ptr[esp + eax * 8 - 1000]);
            mov(ecx, ptr[esp + ecx + 0]);
            mov(ecx, ptr[esp + ecx + 1]);
            mov(ecx, ptr[esp + ecx + 1000]);
            mov(ecx, ptr[esp + ecx - 1]);
            mov(ecx, ptr[esp + ecx - 1000]);
            mov(ecx, ptr[esp + ecx * 1 + 0]);
            mov(ecx, ptr[esp + ecx * 1 + 1]);
            mov(ecx, ptr[esp + ecx * 1 + 1000]);
            mov(ecx, ptr[esp + ecx * 1 - 1]);
            mov(ecx, ptr[esp + ecx * 1 - 1000]);
            mov(ecx, ptr[esp + ecx * 2 + 0]);
            mov(ecx, ptr[esp + ecx * 2 + 1]);
            mov(ecx, ptr[esp + ecx * 2 + 1000]);
            mov(ecx, ptr[esp + ecx * 2 - 1]);
            mov(ecx, ptr[esp + ecx * 2 - 1000]);
            mov(ecx, ptr[esp + ecx * 4 + 0]);
            mov(ecx, ptr[esp + ecx * 4 + 1]);
            mov(ecx, ptr[esp + ecx * 4 + 1000]);
            mov(ecx, ptr[esp + ecx * 4 - 1]);
            mov(ecx, ptr[esp + ecx * 4 - 1000]);
            mov(ecx, ptr[esp + ecx * 8 + 0]);
            mov(ecx, ptr[esp + ecx * 8 + 1]);
            mov(ecx, ptr[esp + ecx * 8 + 1000]);
            mov(ecx, ptr[esp + ecx * 8 - 1]);
            mov(ecx, ptr[esp + ecx * 8 - 1000]);
            mov(ecx, ptr[esp + edx + 0]);
            mov(ecx, ptr[esp + edx + 1]);
            mov(ecx, ptr[esp + edx + 1000]);
            mov(ecx, ptr[esp + edx - 1]);
            mov(ecx, ptr[esp + edx - 1000]);
            mov(ecx, ptr[esp + edx * 1 + 0]);
            mov(ecx, ptr[esp + edx * 1 + 1]);
            mov(ecx, ptr[esp + edx * 1 + 1000]);
            mov(ecx, ptr[esp + edx * 1 - 1]);
            mov(ecx, ptr[esp + edx * 1 - 1000]);
            mov(ecx, ptr[esp + edx * 2 + 0]);
            mov(ecx, ptr[esp + edx * 2 + 1]);
            mov(ecx, ptr[esp + edx * 2 + 1000]);
            mov(ecx, ptr[esp + edx * 2 - 1]);
            mov(ecx, ptr[esp + edx * 2 - 1000]);
            mov(ecx, ptr[esp + edx * 4 + 0]);
            mov(ecx, ptr[esp + edx * 4 + 1]);
            mov(ecx, ptr[esp + edx * 4 + 1000]);
            mov(ecx, ptr[esp + edx * 4 - 1]);
            mov(ecx, ptr[esp + edx * 4 - 1000]);
            mov(ecx, ptr[esp + edx * 8 + 0]);
            mov(ecx, ptr[esp + edx * 8 + 1]);
            mov(ecx, ptr[esp + edx * 8 + 1000]);
            mov(ecx, ptr[esp + edx * 8 - 1]);
            mov(ecx, ptr[esp + edx * 8 - 1000]);
            mov(ecx, ptr[esp + ebx + 0]);
            mov(ecx, ptr[esp + ebx + 1]);
            mov(ecx, ptr[esp + ebx + 1000]);
            mov(ecx, ptr[esp + ebx - 1]);
            mov(ecx, ptr[esp + ebx - 1000]);
            mov(ecx, ptr[esp + ebx * 1 + 0]);
            mov(ecx, ptr[esp + ebx * 1 + 1]);
            mov(ecx, ptr[esp + ebx * 1 + 1000]);
            mov(ecx, ptr[esp + ebx * 1 - 1]);
            mov(ecx, ptr[esp + ebx * 1 - 1000]);
            mov(ecx, ptr[esp + ebx * 2 + 0]);
            mov(ecx, ptr[esp + ebx * 2 + 1]);
            mov(ecx, ptr[esp + ebx * 2 + 1000]);
            mov(ecx, ptr[esp + ebx * 2 - 1]);
            mov(ecx, ptr[esp + ebx * 2 - 1000]);
            mov(ecx, ptr[esp + ebx * 4 + 0]);
            mov(ecx, ptr[esp + ebx * 4 + 1]);
            mov(ecx, ptr[esp + ebx * 4 + 1000]);
            mov(ecx, ptr[esp + ebx * 4 - 1]);
            mov(ecx, ptr[esp + ebx * 4 - 1000]);
            mov(ecx, ptr[esp + ebx * 8 + 0]);
            mov(ecx, ptr[esp + ebx * 8 + 1]);
            mov(ecx, ptr[esp + ebx * 8 + 1000]);
            mov(ecx, ptr[esp + ebx * 8 - 1]);
            mov(ecx, ptr[esp + ebx * 8 - 1000]);
        }
    }

    class gen15 : CodeGenerator {
        this()
        {
            mov(ecx, ptr[esp + ebp + 0]);
            mov(ecx, ptr[esp + ebp + 1]);
            mov(ecx, ptr[esp + ebp + 1000]);
            mov(ecx, ptr[esp + ebp - 1]);
            mov(ecx, ptr[esp + ebp - 1000]);
            mov(ecx, ptr[esp + ebp * 1 + 0]);
            mov(ecx, ptr[esp + ebp * 1 + 1]);
            mov(ecx, ptr[esp + ebp * 1 + 1000]);
            mov(ecx, ptr[esp + ebp * 1 - 1]);
            mov(ecx, ptr[esp + ebp * 1 - 1000]);
            mov(ecx, ptr[esp + ebp * 2 + 0]);
            mov(ecx, ptr[esp + ebp * 2 + 1]);
            mov(ecx, ptr[esp + ebp * 2 + 1000]);
            mov(ecx, ptr[esp + ebp * 2 - 1]);
            mov(ecx, ptr[esp + ebp * 2 - 1000]);
            mov(ecx, ptr[esp + ebp * 4 + 0]);
            mov(ecx, ptr[esp + ebp * 4 + 1]);
            mov(ecx, ptr[esp + ebp * 4 + 1000]);
            mov(ecx, ptr[esp + ebp * 4 - 1]);
            mov(ecx, ptr[esp + ebp * 4 - 1000]);
            mov(ecx, ptr[esp + ebp * 8 + 0]);
            mov(ecx, ptr[esp + ebp * 8 + 1]);
            mov(ecx, ptr[esp + ebp * 8 + 1000]);
            mov(ecx, ptr[esp + ebp * 8 - 1]);
            mov(ecx, ptr[esp + ebp * 8 - 1000]);
            mov(ecx, ptr[esp + esi + 0]);
            mov(ecx, ptr[esp + esi + 1]);
            mov(ecx, ptr[esp + esi + 1000]);
            mov(ecx, ptr[esp + esi - 1]);
            mov(ecx, ptr[esp + esi - 1000]);
            mov(ecx, ptr[esp + esi * 1 + 0]);
            mov(ecx, ptr[esp + esi * 1 + 1]);
            mov(ecx, ptr[esp + esi * 1 + 1000]);
            mov(ecx, ptr[esp + esi * 1 - 1]);
            mov(ecx, ptr[esp + esi * 1 - 1000]);
            mov(ecx, ptr[esp + esi * 2 + 0]);
            mov(ecx, ptr[esp + esi * 2 + 1]);
            mov(ecx, ptr[esp + esi * 2 + 1000]);
            mov(ecx, ptr[esp + esi * 2 - 1]);
            mov(ecx, ptr[esp + esi * 2 - 1000]);
            mov(ecx, ptr[esp + esi * 4 + 0]);
            mov(ecx, ptr[esp + esi * 4 + 1]);
            mov(ecx, ptr[esp + esi * 4 + 1000]);
            mov(ecx, ptr[esp + esi * 4 - 1]);
            mov(ecx, ptr[esp + esi * 4 - 1000]);
            mov(ecx, ptr[esp + esi * 8 + 0]);
            mov(ecx, ptr[esp + esi * 8 + 1]);
            mov(ecx, ptr[esp + esi * 8 + 1000]);
            mov(ecx, ptr[esp + esi * 8 - 1]);
            mov(ecx, ptr[esp + esi * 8 - 1000]);
            mov(ecx, ptr[esp + edi + 0]);
            mov(ecx, ptr[esp + edi + 1]);
            mov(ecx, ptr[esp + edi + 1000]);
            mov(ecx, ptr[esp + edi - 1]);
            mov(ecx, ptr[esp + edi - 1000]);
            mov(ecx, ptr[esp + edi * 1 + 0]);
            mov(ecx, ptr[esp + edi * 1 + 1]);
            mov(ecx, ptr[esp + edi * 1 + 1000]);
            mov(ecx, ptr[esp + edi * 1 - 1]);
            mov(ecx, ptr[esp + edi * 1 - 1000]);
            mov(ecx, ptr[esp + edi * 2 + 0]);
            mov(ecx, ptr[esp + edi * 2 + 1]);
            mov(ecx, ptr[esp + edi * 2 + 1000]);
            mov(ecx, ptr[esp + edi * 2 - 1]);
            mov(ecx, ptr[esp + edi * 2 - 1000]);
            mov(ecx, ptr[esp + edi * 4 + 0]);
            mov(ecx, ptr[esp + edi * 4 + 1]);
            mov(ecx, ptr[esp + edi * 4 + 1000]);
            mov(ecx, ptr[esp + edi * 4 - 1]);
            mov(ecx, ptr[esp + edi * 4 - 1000]);
            mov(ecx, ptr[esp + edi * 8 + 0]);
            mov(ecx, ptr[esp + edi * 8 + 1]);
            mov(ecx, ptr[esp + edi * 8 + 1000]);
            mov(ecx, ptr[esp + edi * 8 - 1]);
            mov(ecx, ptr[esp + edi * 8 - 1000]);
            mov(ecx, ptr[esp + r9d + 0]);
            mov(ecx, ptr[esp + r9d + 1]);
            mov(ecx, ptr[esp + r9d + 1000]);
            mov(ecx, ptr[esp + r9d - 1]);
            mov(ecx, ptr[esp + r9d - 1000]);
            mov(ecx, ptr[esp + r9d * 1 + 0]);
            mov(ecx, ptr[esp + r9d * 1 + 1]);
            mov(ecx, ptr[esp + r9d * 1 + 1000]);
            mov(ecx, ptr[esp + r9d * 1 - 1]);
            mov(ecx, ptr[esp + r9d * 1 - 1000]);
            mov(ecx, ptr[esp + r9d * 2 + 0]);
            mov(ecx, ptr[esp + r9d * 2 + 1]);
            mov(ecx, ptr[esp + r9d * 2 + 1000]);
            mov(ecx, ptr[esp + r9d * 2 - 1]);
            mov(ecx, ptr[esp + r9d * 2 - 1000]);
            mov(ecx, ptr[esp + r9d * 4 + 0]);
            mov(ecx, ptr[esp + r9d * 4 + 1]);
            mov(ecx, ptr[esp + r9d * 4 + 1000]);
            mov(ecx, ptr[esp + r9d * 4 - 1]);
            mov(ecx, ptr[esp + r9d * 4 - 1000]);
            mov(ecx, ptr[esp + r9d * 8 + 0]);
            mov(ecx, ptr[esp + r9d * 8 + 1]);
            mov(ecx, ptr[esp + r9d * 8 + 1000]);
            mov(ecx, ptr[esp + r9d * 8 - 1]);
            mov(ecx, ptr[esp + r9d * 8 - 1000]);
        }
    }

    class gen16 : CodeGenerator {
        this()
        {
            mov(ecx, ptr[esp + r10d + 0]);
            mov(ecx, ptr[esp + r10d + 1]);
            mov(ecx, ptr[esp + r10d + 1000]);
            mov(ecx, ptr[esp + r10d - 1]);
            mov(ecx, ptr[esp + r10d - 1000]);
            mov(ecx, ptr[esp + r10d * 1 + 0]);
            mov(ecx, ptr[esp + r10d * 1 + 1]);
            mov(ecx, ptr[esp + r10d * 1 + 1000]);
            mov(ecx, ptr[esp + r10d * 1 - 1]);
            mov(ecx, ptr[esp + r10d * 1 - 1000]);
            mov(ecx, ptr[esp + r10d * 2 + 0]);
            mov(ecx, ptr[esp + r10d * 2 + 1]);
            mov(ecx, ptr[esp + r10d * 2 + 1000]);
            mov(ecx, ptr[esp + r10d * 2 - 1]);
            mov(ecx, ptr[esp + r10d * 2 - 1000]);
            mov(ecx, ptr[esp + r10d * 4 + 0]);
            mov(ecx, ptr[esp + r10d * 4 + 1]);
            mov(ecx, ptr[esp + r10d * 4 + 1000]);
            mov(ecx, ptr[esp + r10d * 4 - 1]);
            mov(ecx, ptr[esp + r10d * 4 - 1000]);
            mov(ecx, ptr[esp + r10d * 8 + 0]);
            mov(ecx, ptr[esp + r10d * 8 + 1]);
            mov(ecx, ptr[esp + r10d * 8 + 1000]);
            mov(ecx, ptr[esp + r10d * 8 - 1]);
            mov(ecx, ptr[esp + r10d * 8 - 1000]);
            mov(ecx, ptr[esp + r11d + 0]);
            mov(ecx, ptr[esp + r11d + 1]);
            mov(ecx, ptr[esp + r11d + 1000]);
            mov(ecx, ptr[esp + r11d - 1]);
            mov(ecx, ptr[esp + r11d - 1000]);
            mov(ecx, ptr[esp + r11d * 1 + 0]);
            mov(ecx, ptr[esp + r11d * 1 + 1]);
            mov(ecx, ptr[esp + r11d * 1 + 1000]);
            mov(ecx, ptr[esp + r11d * 1 - 1]);
            mov(ecx, ptr[esp + r11d * 1 - 1000]);
            mov(ecx, ptr[esp + r11d * 2 + 0]);
            mov(ecx, ptr[esp + r11d * 2 + 1]);
            mov(ecx, ptr[esp + r11d * 2 + 1000]);
            mov(ecx, ptr[esp + r11d * 2 - 1]);
            mov(ecx, ptr[esp + r11d * 2 - 1000]);
            mov(ecx, ptr[esp + r11d * 4 + 0]);
            mov(ecx, ptr[esp + r11d * 4 + 1]);
            mov(ecx, ptr[esp + r11d * 4 + 1000]);
            mov(ecx, ptr[esp + r11d * 4 - 1]);
            mov(ecx, ptr[esp + r11d * 4 - 1000]);
            mov(ecx, ptr[esp + r11d * 8 + 0]);
            mov(ecx, ptr[esp + r11d * 8 + 1]);
            mov(ecx, ptr[esp + r11d * 8 + 1000]);
            mov(ecx, ptr[esp + r11d * 8 - 1]);
            mov(ecx, ptr[esp + r11d * 8 - 1000]);
            mov(ecx, ptr[esp + r12d + 0]);
            mov(ecx, ptr[esp + r12d + 1]);
            mov(ecx, ptr[esp + r12d + 1000]);
            mov(ecx, ptr[esp + r12d - 1]);
            mov(ecx, ptr[esp + r12d - 1000]);
            mov(ecx, ptr[esp + r12d * 1 + 0]);
            mov(ecx, ptr[esp + r12d * 1 + 1]);
            mov(ecx, ptr[esp + r12d * 1 + 1000]);
            mov(ecx, ptr[esp + r12d * 1 - 1]);
            mov(ecx, ptr[esp + r12d * 1 - 1000]);
            mov(ecx, ptr[esp + r12d * 2 + 0]);
            mov(ecx, ptr[esp + r12d * 2 + 1]);
            mov(ecx, ptr[esp + r12d * 2 + 1000]);
            mov(ecx, ptr[esp + r12d * 2 - 1]);
            mov(ecx, ptr[esp + r12d * 2 - 1000]);
            mov(ecx, ptr[esp + r12d * 4 + 0]);
            mov(ecx, ptr[esp + r12d * 4 + 1]);
            mov(ecx, ptr[esp + r12d * 4 + 1000]);
            mov(ecx, ptr[esp + r12d * 4 - 1]);
            mov(ecx, ptr[esp + r12d * 4 - 1000]);
            mov(ecx, ptr[esp + r12d * 8 + 0]);
            mov(ecx, ptr[esp + r12d * 8 + 1]);
            mov(ecx, ptr[esp + r12d * 8 + 1000]);
            mov(ecx, ptr[esp + r12d * 8 - 1]);
            mov(ecx, ptr[esp + r12d * 8 - 1000]);
            mov(ecx, ptr[esp + r13d + 0]);
            mov(ecx, ptr[esp + r13d + 1]);
            mov(ecx, ptr[esp + r13d + 1000]);
            mov(ecx, ptr[esp + r13d - 1]);
            mov(ecx, ptr[esp + r13d - 1000]);
            mov(ecx, ptr[esp + r13d * 1 + 0]);
            mov(ecx, ptr[esp + r13d * 1 + 1]);
            mov(ecx, ptr[esp + r13d * 1 + 1000]);
            mov(ecx, ptr[esp + r13d * 1 - 1]);
            mov(ecx, ptr[esp + r13d * 1 - 1000]);
            mov(ecx, ptr[esp + r13d * 2 + 0]);
            mov(ecx, ptr[esp + r13d * 2 + 1]);
            mov(ecx, ptr[esp + r13d * 2 + 1000]);
            mov(ecx, ptr[esp + r13d * 2 - 1]);
            mov(ecx, ptr[esp + r13d * 2 - 1000]);
            mov(ecx, ptr[esp + r13d * 4 + 0]);
            mov(ecx, ptr[esp + r13d * 4 + 1]);
            mov(ecx, ptr[esp + r13d * 4 + 1000]);
            mov(ecx, ptr[esp + r13d * 4 - 1]);
            mov(ecx, ptr[esp + r13d * 4 - 1000]);
            mov(ecx, ptr[esp + r13d * 8 + 0]);
            mov(ecx, ptr[esp + r13d * 8 + 1]);
            mov(ecx, ptr[esp + r13d * 8 + 1000]);
            mov(ecx, ptr[esp + r13d * 8 - 1]);
            mov(ecx, ptr[esp + r13d * 8 - 1000]);
        }
    }

    class gen17 : CodeGenerator {
        this()
        {
            mov(ecx, ptr[esp + r14d + 0]);
            mov(ecx, ptr[esp + r14d + 1]);
            mov(ecx, ptr[esp + r14d + 1000]);
            mov(ecx, ptr[esp + r14d - 1]);
            mov(ecx, ptr[esp + r14d - 1000]);
            mov(ecx, ptr[esp + r14d * 1 + 0]);
            mov(ecx, ptr[esp + r14d * 1 + 1]);
            mov(ecx, ptr[esp + r14d * 1 + 1000]);
            mov(ecx, ptr[esp + r14d * 1 - 1]);
            mov(ecx, ptr[esp + r14d * 1 - 1000]);
            mov(ecx, ptr[esp + r14d * 2 + 0]);
            mov(ecx, ptr[esp + r14d * 2 + 1]);
            mov(ecx, ptr[esp + r14d * 2 + 1000]);
            mov(ecx, ptr[esp + r14d * 2 - 1]);
            mov(ecx, ptr[esp + r14d * 2 - 1000]);
            mov(ecx, ptr[esp + r14d * 4 + 0]);
            mov(ecx, ptr[esp + r14d * 4 + 1]);
            mov(ecx, ptr[esp + r14d * 4 + 1000]);
            mov(ecx, ptr[esp + r14d * 4 - 1]);
            mov(ecx, ptr[esp + r14d * 4 - 1000]);
            mov(ecx, ptr[esp + r14d * 8 + 0]);
            mov(ecx, ptr[esp + r14d * 8 + 1]);
            mov(ecx, ptr[esp + r14d * 8 + 1000]);
            mov(ecx, ptr[esp + r14d * 8 - 1]);
            mov(ecx, ptr[esp + r14d * 8 - 1000]);
            mov(ecx, ptr[esp + r15d + 0]);
            mov(ecx, ptr[esp + r15d + 1]);
            mov(ecx, ptr[esp + r15d + 1000]);
            mov(ecx, ptr[esp + r15d - 1]);
            mov(ecx, ptr[esp + r15d - 1000]);
            mov(ecx, ptr[esp + r15d * 1 + 0]);
            mov(ecx, ptr[esp + r15d * 1 + 1]);
            mov(ecx, ptr[esp + r15d * 1 + 1000]);
            mov(ecx, ptr[esp + r15d * 1 - 1]);
            mov(ecx, ptr[esp + r15d * 1 - 1000]);
            mov(ecx, ptr[esp + r15d * 2 + 0]);
            mov(ecx, ptr[esp + r15d * 2 + 1]);
            mov(ecx, ptr[esp + r15d * 2 + 1000]);
            mov(ecx, ptr[esp + r15d * 2 - 1]);
            mov(ecx, ptr[esp + r15d * 2 - 1000]);
            mov(ecx, ptr[esp + r15d * 4 + 0]);
            mov(ecx, ptr[esp + r15d * 4 + 1]);
            mov(ecx, ptr[esp + r15d * 4 + 1000]);
            mov(ecx, ptr[esp + r15d * 4 - 1]);
            mov(ecx, ptr[esp + r15d * 4 - 1000]);
            mov(ecx, ptr[esp + r15d * 8 + 0]);
            mov(ecx, ptr[esp + r15d * 8 + 1]);
            mov(ecx, ptr[esp + r15d * 8 + 1000]);
            mov(ecx, ptr[esp + r15d * 8 - 1]);
            mov(ecx, ptr[esp + r15d * 8 - 1000]);
            mov(ecx, ptr[ebp + eax + 0]);
            mov(ecx, ptr[ebp + eax + 1]);
            mov(ecx, ptr[ebp + eax + 1000]);
            mov(ecx, ptr[ebp + eax - 1]);
            mov(ecx, ptr[ebp + eax - 1000]);
            mov(ecx, ptr[ebp + eax * 1 + 0]);
            mov(ecx, ptr[ebp + eax * 1 + 1]);
            mov(ecx, ptr[ebp + eax * 1 + 1000]);
            mov(ecx, ptr[ebp + eax * 1 - 1]);
            mov(ecx, ptr[ebp + eax * 1 - 1000]);
            mov(ecx, ptr[ebp + eax * 2 + 0]);
            mov(ecx, ptr[ebp + eax * 2 + 1]);
            mov(ecx, ptr[ebp + eax * 2 + 1000]);
            mov(ecx, ptr[ebp + eax * 2 - 1]);
            mov(ecx, ptr[ebp + eax * 2 - 1000]);
            mov(ecx, ptr[ebp + eax * 4 + 0]);
            mov(ecx, ptr[ebp + eax * 4 + 1]);
            mov(ecx, ptr[ebp + eax * 4 + 1000]);
            mov(ecx, ptr[ebp + eax * 4 - 1]);
            mov(ecx, ptr[ebp + eax * 4 - 1000]);
            mov(ecx, ptr[ebp + eax * 8 + 0]);
            mov(ecx, ptr[ebp + eax * 8 + 1]);
            mov(ecx, ptr[ebp + eax * 8 + 1000]);
            mov(ecx, ptr[ebp + eax * 8 - 1]);
            mov(ecx, ptr[ebp + eax * 8 - 1000]);
            mov(ecx, ptr[ebp + ecx + 0]);
            mov(ecx, ptr[ebp + ecx + 1]);
            mov(ecx, ptr[ebp + ecx + 1000]);
            mov(ecx, ptr[ebp + ecx - 1]);
            mov(ecx, ptr[ebp + ecx - 1000]);
            mov(ecx, ptr[ebp + ecx * 1 + 0]);
            mov(ecx, ptr[ebp + ecx * 1 + 1]);
            mov(ecx, ptr[ebp + ecx * 1 + 1000]);
            mov(ecx, ptr[ebp + ecx * 1 - 1]);
            mov(ecx, ptr[ebp + ecx * 1 - 1000]);
            mov(ecx, ptr[ebp + ecx * 2 + 0]);
            mov(ecx, ptr[ebp + ecx * 2 + 1]);
            mov(ecx, ptr[ebp + ecx * 2 + 1000]);
            mov(ecx, ptr[ebp + ecx * 2 - 1]);
            mov(ecx, ptr[ebp + ecx * 2 - 1000]);
            mov(ecx, ptr[ebp + ecx * 4 + 0]);
            mov(ecx, ptr[ebp + ecx * 4 + 1]);
            mov(ecx, ptr[ebp + ecx * 4 + 1000]);
            mov(ecx, ptr[ebp + ecx * 4 - 1]);
            mov(ecx, ptr[ebp + ecx * 4 - 1000]);
            mov(ecx, ptr[ebp + ecx * 8 + 0]);
            mov(ecx, ptr[ebp + ecx * 8 + 1]);
            mov(ecx, ptr[ebp + ecx * 8 + 1000]);
            mov(ecx, ptr[ebp + ecx * 8 - 1]);
            mov(ecx, ptr[ebp + ecx * 8 - 1000]);
        }
    }

    class gen18 : CodeGenerator {
        this()
        {
            mov(ecx, ptr[ebp + edx + 0]);
            mov(ecx, ptr[ebp + edx + 1]);
            mov(ecx, ptr[ebp + edx + 1000]);
            mov(ecx, ptr[ebp + edx - 1]);
            mov(ecx, ptr[ebp + edx - 1000]);
            mov(ecx, ptr[ebp + edx * 1 + 0]);
            mov(ecx, ptr[ebp + edx * 1 + 1]);
            mov(ecx, ptr[ebp + edx * 1 + 1000]);
            mov(ecx, ptr[ebp + edx * 1 - 1]);
            mov(ecx, ptr[ebp + edx * 1 - 1000]);
            mov(ecx, ptr[ebp + edx * 2 + 0]);
            mov(ecx, ptr[ebp + edx * 2 + 1]);
            mov(ecx, ptr[ebp + edx * 2 + 1000]);
            mov(ecx, ptr[ebp + edx * 2 - 1]);
            mov(ecx, ptr[ebp + edx * 2 - 1000]);
            mov(ecx, ptr[ebp + edx * 4 + 0]);
            mov(ecx, ptr[ebp + edx * 4 + 1]);
            mov(ecx, ptr[ebp + edx * 4 + 1000]);
            mov(ecx, ptr[ebp + edx * 4 - 1]);
            mov(ecx, ptr[ebp + edx * 4 - 1000]);
            mov(ecx, ptr[ebp + edx * 8 + 0]);
            mov(ecx, ptr[ebp + edx * 8 + 1]);
            mov(ecx, ptr[ebp + edx * 8 + 1000]);
            mov(ecx, ptr[ebp + edx * 8 - 1]);
            mov(ecx, ptr[ebp + edx * 8 - 1000]);
            mov(ecx, ptr[ebp + ebx + 0]);
            mov(ecx, ptr[ebp + ebx + 1]);
            mov(ecx, ptr[ebp + ebx + 1000]);
            mov(ecx, ptr[ebp + ebx - 1]);
            mov(ecx, ptr[ebp + ebx - 1000]);
            mov(ecx, ptr[ebp + ebx * 1 + 0]);
            mov(ecx, ptr[ebp + ebx * 1 + 1]);
            mov(ecx, ptr[ebp + ebx * 1 + 1000]);
            mov(ecx, ptr[ebp + ebx * 1 - 1]);
            mov(ecx, ptr[ebp + ebx * 1 - 1000]);
            mov(ecx, ptr[ebp + ebx * 2 + 0]);
            mov(ecx, ptr[ebp + ebx * 2 + 1]);
            mov(ecx, ptr[ebp + ebx * 2 + 1000]);
            mov(ecx, ptr[ebp + ebx * 2 - 1]);
            mov(ecx, ptr[ebp + ebx * 2 - 1000]);
            mov(ecx, ptr[ebp + ebx * 4 + 0]);
            mov(ecx, ptr[ebp + ebx * 4 + 1]);
            mov(ecx, ptr[ebp + ebx * 4 + 1000]);
            mov(ecx, ptr[ebp + ebx * 4 - 1]);
            mov(ecx, ptr[ebp + ebx * 4 - 1000]);
            mov(ecx, ptr[ebp + ebx * 8 + 0]);
            mov(ecx, ptr[ebp + ebx * 8 + 1]);
            mov(ecx, ptr[ebp + ebx * 8 + 1000]);
            mov(ecx, ptr[ebp + ebx * 8 - 1]);
            mov(ecx, ptr[ebp + ebx * 8 - 1000]);
            mov(ecx, ptr[ebp + ebp + 0]);
            mov(ecx, ptr[ebp + ebp + 1]);
            mov(ecx, ptr[ebp + ebp + 1000]);
            mov(ecx, ptr[ebp + ebp - 1]);
            mov(ecx, ptr[ebp + ebp - 1000]);
            mov(ecx, ptr[ebp + ebp * 1 + 0]);
            mov(ecx, ptr[ebp + ebp * 1 + 1]);
            mov(ecx, ptr[ebp + ebp * 1 + 1000]);
            mov(ecx, ptr[ebp + ebp * 1 - 1]);
            mov(ecx, ptr[ebp + ebp * 1 - 1000]);
            mov(ecx, ptr[ebp + ebp * 2 + 0]);
            mov(ecx, ptr[ebp + ebp * 2 + 1]);
            mov(ecx, ptr[ebp + ebp * 2 + 1000]);
            mov(ecx, ptr[ebp + ebp * 2 - 1]);
            mov(ecx, ptr[ebp + ebp * 2 - 1000]);
            mov(ecx, ptr[ebp + ebp * 4 + 0]);
            mov(ecx, ptr[ebp + ebp * 4 + 1]);
            mov(ecx, ptr[ebp + ebp * 4 + 1000]);
            mov(ecx, ptr[ebp + ebp * 4 - 1]);
            mov(ecx, ptr[ebp + ebp * 4 - 1000]);
            mov(ecx, ptr[ebp + ebp * 8 + 0]);
            mov(ecx, ptr[ebp + ebp * 8 + 1]);
            mov(ecx, ptr[ebp + ebp * 8 + 1000]);
            mov(ecx, ptr[ebp + ebp * 8 - 1]);
            mov(ecx, ptr[ebp + ebp * 8 - 1000]);
            mov(ecx, ptr[ebp + esi + 0]);
            mov(ecx, ptr[ebp + esi + 1]);
            mov(ecx, ptr[ebp + esi + 1000]);
            mov(ecx, ptr[ebp + esi - 1]);
            mov(ecx, ptr[ebp + esi - 1000]);
            mov(ecx, ptr[ebp + esi * 1 + 0]);
            mov(ecx, ptr[ebp + esi * 1 + 1]);
            mov(ecx, ptr[ebp + esi * 1 + 1000]);
            mov(ecx, ptr[ebp + esi * 1 - 1]);
            mov(ecx, ptr[ebp + esi * 1 - 1000]);
            mov(ecx, ptr[ebp + esi * 2 + 0]);
            mov(ecx, ptr[ebp + esi * 2 + 1]);
            mov(ecx, ptr[ebp + esi * 2 + 1000]);
            mov(ecx, ptr[ebp + esi * 2 - 1]);
            mov(ecx, ptr[ebp + esi * 2 - 1000]);
            mov(ecx, ptr[ebp + esi * 4 + 0]);
            mov(ecx, ptr[ebp + esi * 4 + 1]);
            mov(ecx, ptr[ebp + esi * 4 + 1000]);
            mov(ecx, ptr[ebp + esi * 4 - 1]);
            mov(ecx, ptr[ebp + esi * 4 - 1000]);
            mov(ecx, ptr[ebp + esi * 8 + 0]);
            mov(ecx, ptr[ebp + esi * 8 + 1]);
            mov(ecx, ptr[ebp + esi * 8 + 1000]);
            mov(ecx, ptr[ebp + esi * 8 - 1]);
            mov(ecx, ptr[ebp + esi * 8 - 1000]);
        }
    }

    class gen19 : CodeGenerator {
        this()
        {
            mov(ecx, ptr[ebp + edi + 0]);
            mov(ecx, ptr[ebp + edi + 1]);
            mov(ecx, ptr[ebp + edi + 1000]);
            mov(ecx, ptr[ebp + edi - 1]);
            mov(ecx, ptr[ebp + edi - 1000]);
            mov(ecx, ptr[ebp + edi * 1 + 0]);
            mov(ecx, ptr[ebp + edi * 1 + 1]);
            mov(ecx, ptr[ebp + edi * 1 + 1000]);
            mov(ecx, ptr[ebp + edi * 1 - 1]);
            mov(ecx, ptr[ebp + edi * 1 - 1000]);
            mov(ecx, ptr[ebp + edi * 2 + 0]);
            mov(ecx, ptr[ebp + edi * 2 + 1]);
            mov(ecx, ptr[ebp + edi * 2 + 1000]);
            mov(ecx, ptr[ebp + edi * 2 - 1]);
            mov(ecx, ptr[ebp + edi * 2 - 1000]);
            mov(ecx, ptr[ebp + edi * 4 + 0]);
            mov(ecx, ptr[ebp + edi * 4 + 1]);
            mov(ecx, ptr[ebp + edi * 4 + 1000]);
            mov(ecx, ptr[ebp + edi * 4 - 1]);
            mov(ecx, ptr[ebp + edi * 4 - 1000]);
            mov(ecx, ptr[ebp + edi * 8 + 0]);
            mov(ecx, ptr[ebp + edi * 8 + 1]);
            mov(ecx, ptr[ebp + edi * 8 + 1000]);
            mov(ecx, ptr[ebp + edi * 8 - 1]);
            mov(ecx, ptr[ebp + edi * 8 - 1000]);
            mov(ecx, ptr[ebp + r9d + 0]);
            mov(ecx, ptr[ebp + r9d + 1]);
            mov(ecx, ptr[ebp + r9d + 1000]);
            mov(ecx, ptr[ebp + r9d - 1]);
            mov(ecx, ptr[ebp + r9d - 1000]);
            mov(ecx, ptr[ebp + r9d * 1 + 0]);
            mov(ecx, ptr[ebp + r9d * 1 + 1]);
            mov(ecx, ptr[ebp + r9d * 1 + 1000]);
            mov(ecx, ptr[ebp + r9d * 1 - 1]);
            mov(ecx, ptr[ebp + r9d * 1 - 1000]);
            mov(ecx, ptr[ebp + r9d * 2 + 0]);
            mov(ecx, ptr[ebp + r9d * 2 + 1]);
            mov(ecx, ptr[ebp + r9d * 2 + 1000]);
            mov(ecx, ptr[ebp + r9d * 2 - 1]);
            mov(ecx, ptr[ebp + r9d * 2 - 1000]);
            mov(ecx, ptr[ebp + r9d * 4 + 0]);
            mov(ecx, ptr[ebp + r9d * 4 + 1]);
            mov(ecx, ptr[ebp + r9d * 4 + 1000]);
            mov(ecx, ptr[ebp + r9d * 4 - 1]);
            mov(ecx, ptr[ebp + r9d * 4 - 1000]);
            mov(ecx, ptr[ebp + r9d * 8 + 0]);
            mov(ecx, ptr[ebp + r9d * 8 + 1]);
            mov(ecx, ptr[ebp + r9d * 8 + 1000]);
            mov(ecx, ptr[ebp + r9d * 8 - 1]);
            mov(ecx, ptr[ebp + r9d * 8 - 1000]);
            mov(ecx, ptr[ebp + r10d + 0]);
            mov(ecx, ptr[ebp + r10d + 1]);
            mov(ecx, ptr[ebp + r10d + 1000]);
            mov(ecx, ptr[ebp + r10d - 1]);
            mov(ecx, ptr[ebp + r10d - 1000]);
            mov(ecx, ptr[ebp + r10d * 1 + 0]);
            mov(ecx, ptr[ebp + r10d * 1 + 1]);
            mov(ecx, ptr[ebp + r10d * 1 + 1000]);
            mov(ecx, ptr[ebp + r10d * 1 - 1]);
            mov(ecx, ptr[ebp + r10d * 1 - 1000]);
            mov(ecx, ptr[ebp + r10d * 2 + 0]);
            mov(ecx, ptr[ebp + r10d * 2 + 1]);
            mov(ecx, ptr[ebp + r10d * 2 + 1000]);
            mov(ecx, ptr[ebp + r10d * 2 - 1]);
            mov(ecx, ptr[ebp + r10d * 2 - 1000]);
            mov(ecx, ptr[ebp + r10d * 4 + 0]);
            mov(ecx, ptr[ebp + r10d * 4 + 1]);
            mov(ecx, ptr[ebp + r10d * 4 + 1000]);
            mov(ecx, ptr[ebp + r10d * 4 - 1]);
            mov(ecx, ptr[ebp + r10d * 4 - 1000]);
            mov(ecx, ptr[ebp + r10d * 8 + 0]);
            mov(ecx, ptr[ebp + r10d * 8 + 1]);
            mov(ecx, ptr[ebp + r10d * 8 + 1000]);
            mov(ecx, ptr[ebp + r10d * 8 - 1]);
            mov(ecx, ptr[ebp + r10d * 8 - 1000]);
            mov(ecx, ptr[ebp + r11d + 0]);
            mov(ecx, ptr[ebp + r11d + 1]);
            mov(ecx, ptr[ebp + r11d + 1000]);
            mov(ecx, ptr[ebp + r11d - 1]);
            mov(ecx, ptr[ebp + r11d - 1000]);
            mov(ecx, ptr[ebp + r11d * 1 + 0]);
            mov(ecx, ptr[ebp + r11d * 1 + 1]);
            mov(ecx, ptr[ebp + r11d * 1 + 1000]);
            mov(ecx, ptr[ebp + r11d * 1 - 1]);
            mov(ecx, ptr[ebp + r11d * 1 - 1000]);
            mov(ecx, ptr[ebp + r11d * 2 + 0]);
            mov(ecx, ptr[ebp + r11d * 2 + 1]);
            mov(ecx, ptr[ebp + r11d * 2 + 1000]);
            mov(ecx, ptr[ebp + r11d * 2 - 1]);
            mov(ecx, ptr[ebp + r11d * 2 - 1000]);
            mov(ecx, ptr[ebp + r11d * 4 + 0]);
            mov(ecx, ptr[ebp + r11d * 4 + 1]);
            mov(ecx, ptr[ebp + r11d * 4 + 1000]);
            mov(ecx, ptr[ebp + r11d * 4 - 1]);
            mov(ecx, ptr[ebp + r11d * 4 - 1000]);
            mov(ecx, ptr[ebp + r11d * 8 + 0]);
            mov(ecx, ptr[ebp + r11d * 8 + 1]);
            mov(ecx, ptr[ebp + r11d * 8 + 1000]);
            mov(ecx, ptr[ebp + r11d * 8 - 1]);
            mov(ecx, ptr[ebp + r11d * 8 - 1000]);
        }
    }

    class gen20 : CodeGenerator {
        this()
        {
            mov(ecx, ptr[ebp + r12d + 0]);
            mov(ecx, ptr[ebp + r12d + 1]);
            mov(ecx, ptr[ebp + r12d + 1000]);
            mov(ecx, ptr[ebp + r12d - 1]);
            mov(ecx, ptr[ebp + r12d - 1000]);
            mov(ecx, ptr[ebp + r12d * 1 + 0]);
            mov(ecx, ptr[ebp + r12d * 1 + 1]);
            mov(ecx, ptr[ebp + r12d * 1 + 1000]);
            mov(ecx, ptr[ebp + r12d * 1 - 1]);
            mov(ecx, ptr[ebp + r12d * 1 - 1000]);
            mov(ecx, ptr[ebp + r12d * 2 + 0]);
            mov(ecx, ptr[ebp + r12d * 2 + 1]);
            mov(ecx, ptr[ebp + r12d * 2 + 1000]);
            mov(ecx, ptr[ebp + r12d * 2 - 1]);
            mov(ecx, ptr[ebp + r12d * 2 - 1000]);
            mov(ecx, ptr[ebp + r12d * 4 + 0]);
            mov(ecx, ptr[ebp + r12d * 4 + 1]);
            mov(ecx, ptr[ebp + r12d * 4 + 1000]);
            mov(ecx, ptr[ebp + r12d * 4 - 1]);
            mov(ecx, ptr[ebp + r12d * 4 - 1000]);
            mov(ecx, ptr[ebp + r12d * 8 + 0]);
            mov(ecx, ptr[ebp + r12d * 8 + 1]);
            mov(ecx, ptr[ebp + r12d * 8 + 1000]);
            mov(ecx, ptr[ebp + r12d * 8 - 1]);
            mov(ecx, ptr[ebp + r12d * 8 - 1000]);
            mov(ecx, ptr[ebp + r13d + 0]);
            mov(ecx, ptr[ebp + r13d + 1]);
            mov(ecx, ptr[ebp + r13d + 1000]);
            mov(ecx, ptr[ebp + r13d - 1]);
            mov(ecx, ptr[ebp + r13d - 1000]);
            mov(ecx, ptr[ebp + r13d * 1 + 0]);
            mov(ecx, ptr[ebp + r13d * 1 + 1]);
            mov(ecx, ptr[ebp + r13d * 1 + 1000]);
            mov(ecx, ptr[ebp + r13d * 1 - 1]);
            mov(ecx, ptr[ebp + r13d * 1 - 1000]);
            mov(ecx, ptr[ebp + r13d * 2 + 0]);
            mov(ecx, ptr[ebp + r13d * 2 + 1]);
            mov(ecx, ptr[ebp + r13d * 2 + 1000]);
            mov(ecx, ptr[ebp + r13d * 2 - 1]);
            mov(ecx, ptr[ebp + r13d * 2 - 1000]);
            mov(ecx, ptr[ebp + r13d * 4 + 0]);
            mov(ecx, ptr[ebp + r13d * 4 + 1]);
            mov(ecx, ptr[ebp + r13d * 4 + 1000]);
            mov(ecx, ptr[ebp + r13d * 4 - 1]);
            mov(ecx, ptr[ebp + r13d * 4 - 1000]);
            mov(ecx, ptr[ebp + r13d * 8 + 0]);
            mov(ecx, ptr[ebp + r13d * 8 + 1]);
            mov(ecx, ptr[ebp + r13d * 8 + 1000]);
            mov(ecx, ptr[ebp + r13d * 8 - 1]);
            mov(ecx, ptr[ebp + r13d * 8 - 1000]);
            mov(ecx, ptr[ebp + r14d + 0]);
            mov(ecx, ptr[ebp + r14d + 1]);
            mov(ecx, ptr[ebp + r14d + 1000]);
            mov(ecx, ptr[ebp + r14d - 1]);
            mov(ecx, ptr[ebp + r14d - 1000]);
            mov(ecx, ptr[ebp + r14d * 1 + 0]);
            mov(ecx, ptr[ebp + r14d * 1 + 1]);
            mov(ecx, ptr[ebp + r14d * 1 + 1000]);
            mov(ecx, ptr[ebp + r14d * 1 - 1]);
            mov(ecx, ptr[ebp + r14d * 1 - 1000]);
            mov(ecx, ptr[ebp + r14d * 2 + 0]);
            mov(ecx, ptr[ebp + r14d * 2 + 1]);
            mov(ecx, ptr[ebp + r14d * 2 + 1000]);
            mov(ecx, ptr[ebp + r14d * 2 - 1]);
            mov(ecx, ptr[ebp + r14d * 2 - 1000]);
            mov(ecx, ptr[ebp + r14d * 4 + 0]);
            mov(ecx, ptr[ebp + r14d * 4 + 1]);
            mov(ecx, ptr[ebp + r14d * 4 + 1000]);
            mov(ecx, ptr[ebp + r14d * 4 - 1]);
            mov(ecx, ptr[ebp + r14d * 4 - 1000]);
            mov(ecx, ptr[ebp + r14d * 8 + 0]);
            mov(ecx, ptr[ebp + r14d * 8 + 1]);
            mov(ecx, ptr[ebp + r14d * 8 + 1000]);
            mov(ecx, ptr[ebp + r14d * 8 - 1]);
            mov(ecx, ptr[ebp + r14d * 8 - 1000]);
            mov(ecx, ptr[ebp + r15d + 0]);
            mov(ecx, ptr[ebp + r15d + 1]);
            mov(ecx, ptr[ebp + r15d + 1000]);
            mov(ecx, ptr[ebp + r15d - 1]);
            mov(ecx, ptr[ebp + r15d - 1000]);
            mov(ecx, ptr[ebp + r15d * 1 + 0]);
            mov(ecx, ptr[ebp + r15d * 1 + 1]);
            mov(ecx, ptr[ebp + r15d * 1 + 1000]);
            mov(ecx, ptr[ebp + r15d * 1 - 1]);
            mov(ecx, ptr[ebp + r15d * 1 - 1000]);
            mov(ecx, ptr[ebp + r15d * 2 + 0]);
            mov(ecx, ptr[ebp + r15d * 2 + 1]);
            mov(ecx, ptr[ebp + r15d * 2 + 1000]);
            mov(ecx, ptr[ebp + r15d * 2 - 1]);
            mov(ecx, ptr[ebp + r15d * 2 - 1000]);
            mov(ecx, ptr[ebp + r15d * 4 + 0]);
            mov(ecx, ptr[ebp + r15d * 4 + 1]);
            mov(ecx, ptr[ebp + r15d * 4 + 1000]);
            mov(ecx, ptr[ebp + r15d * 4 - 1]);
            mov(ecx, ptr[ebp + r15d * 4 - 1000]);
            mov(ecx, ptr[ebp + r15d * 8 + 0]);
            mov(ecx, ptr[ebp + r15d * 8 + 1]);
            mov(ecx, ptr[ebp + r15d * 8 + 1000]);
            mov(ecx, ptr[ebp + r15d * 8 - 1]);
            mov(ecx, ptr[ebp + r15d * 8 - 1000]);
        }
    }

    class gen21 : CodeGenerator {
        this()
        {
            mov(ecx, ptr[esi + eax + 0]);
            mov(ecx, ptr[esi + eax + 1]);
            mov(ecx, ptr[esi + eax + 1000]);
            mov(ecx, ptr[esi + eax - 1]);
            mov(ecx, ptr[esi + eax - 1000]);
            mov(ecx, ptr[esi + eax * 1 + 0]);
            mov(ecx, ptr[esi + eax * 1 + 1]);
            mov(ecx, ptr[esi + eax * 1 + 1000]);
            mov(ecx, ptr[esi + eax * 1 - 1]);
            mov(ecx, ptr[esi + eax * 1 - 1000]);
            mov(ecx, ptr[esi + eax * 2 + 0]);
            mov(ecx, ptr[esi + eax * 2 + 1]);
            mov(ecx, ptr[esi + eax * 2 + 1000]);
            mov(ecx, ptr[esi + eax * 2 - 1]);
            mov(ecx, ptr[esi + eax * 2 - 1000]);
            mov(ecx, ptr[esi + eax * 4 + 0]);
            mov(ecx, ptr[esi + eax * 4 + 1]);
            mov(ecx, ptr[esi + eax * 4 + 1000]);
            mov(ecx, ptr[esi + eax * 4 - 1]);
            mov(ecx, ptr[esi + eax * 4 - 1000]);
            mov(ecx, ptr[esi + eax * 8 + 0]);
            mov(ecx, ptr[esi + eax * 8 + 1]);
            mov(ecx, ptr[esi + eax * 8 + 1000]);
            mov(ecx, ptr[esi + eax * 8 - 1]);
            mov(ecx, ptr[esi + eax * 8 - 1000]);
            mov(ecx, ptr[esi + ecx + 0]);
            mov(ecx, ptr[esi + ecx + 1]);
            mov(ecx, ptr[esi + ecx + 1000]);
            mov(ecx, ptr[esi + ecx - 1]);
            mov(ecx, ptr[esi + ecx - 1000]);
            mov(ecx, ptr[esi + ecx * 1 + 0]);
            mov(ecx, ptr[esi + ecx * 1 + 1]);
            mov(ecx, ptr[esi + ecx * 1 + 1000]);
            mov(ecx, ptr[esi + ecx * 1 - 1]);
            mov(ecx, ptr[esi + ecx * 1 - 1000]);
            mov(ecx, ptr[esi + ecx * 2 + 0]);
            mov(ecx, ptr[esi + ecx * 2 + 1]);
            mov(ecx, ptr[esi + ecx * 2 + 1000]);
            mov(ecx, ptr[esi + ecx * 2 - 1]);
            mov(ecx, ptr[esi + ecx * 2 - 1000]);
            mov(ecx, ptr[esi + ecx * 4 + 0]);
            mov(ecx, ptr[esi + ecx * 4 + 1]);
            mov(ecx, ptr[esi + ecx * 4 + 1000]);
            mov(ecx, ptr[esi + ecx * 4 - 1]);
            mov(ecx, ptr[esi + ecx * 4 - 1000]);
            mov(ecx, ptr[esi + ecx * 8 + 0]);
            mov(ecx, ptr[esi + ecx * 8 + 1]);
            mov(ecx, ptr[esi + ecx * 8 + 1000]);
            mov(ecx, ptr[esi + ecx * 8 - 1]);
            mov(ecx, ptr[esi + ecx * 8 - 1000]);
            mov(ecx, ptr[esi + edx + 0]);
            mov(ecx, ptr[esi + edx + 1]);
            mov(ecx, ptr[esi + edx + 1000]);
            mov(ecx, ptr[esi + edx - 1]);
            mov(ecx, ptr[esi + edx - 1000]);
            mov(ecx, ptr[esi + edx * 1 + 0]);
            mov(ecx, ptr[esi + edx * 1 + 1]);
            mov(ecx, ptr[esi + edx * 1 + 1000]);
            mov(ecx, ptr[esi + edx * 1 - 1]);
            mov(ecx, ptr[esi + edx * 1 - 1000]);
            mov(ecx, ptr[esi + edx * 2 + 0]);
            mov(ecx, ptr[esi + edx * 2 + 1]);
            mov(ecx, ptr[esi + edx * 2 + 1000]);
            mov(ecx, ptr[esi + edx * 2 - 1]);
            mov(ecx, ptr[esi + edx * 2 - 1000]);
            mov(ecx, ptr[esi + edx * 4 + 0]);
            mov(ecx, ptr[esi + edx * 4 + 1]);
            mov(ecx, ptr[esi + edx * 4 + 1000]);
            mov(ecx, ptr[esi + edx * 4 - 1]);
            mov(ecx, ptr[esi + edx * 4 - 1000]);
            mov(ecx, ptr[esi + edx * 8 + 0]);
            mov(ecx, ptr[esi + edx * 8 + 1]);
            mov(ecx, ptr[esi + edx * 8 + 1000]);
            mov(ecx, ptr[esi + edx * 8 - 1]);
            mov(ecx, ptr[esi + edx * 8 - 1000]);
            mov(ecx, ptr[esi + ebx + 0]);
            mov(ecx, ptr[esi + ebx + 1]);
            mov(ecx, ptr[esi + ebx + 1000]);
            mov(ecx, ptr[esi + ebx - 1]);
            mov(ecx, ptr[esi + ebx - 1000]);
            mov(ecx, ptr[esi + ebx * 1 + 0]);
            mov(ecx, ptr[esi + ebx * 1 + 1]);
            mov(ecx, ptr[esi + ebx * 1 + 1000]);
            mov(ecx, ptr[esi + ebx * 1 - 1]);
            mov(ecx, ptr[esi + ebx * 1 - 1000]);
            mov(ecx, ptr[esi + ebx * 2 + 0]);
            mov(ecx, ptr[esi + ebx * 2 + 1]);
            mov(ecx, ptr[esi + ebx * 2 + 1000]);
            mov(ecx, ptr[esi + ebx * 2 - 1]);
            mov(ecx, ptr[esi + ebx * 2 - 1000]);
            mov(ecx, ptr[esi + ebx * 4 + 0]);
            mov(ecx, ptr[esi + ebx * 4 + 1]);
            mov(ecx, ptr[esi + ebx * 4 + 1000]);
            mov(ecx, ptr[esi + ebx * 4 - 1]);
            mov(ecx, ptr[esi + ebx * 4 - 1000]);
            mov(ecx, ptr[esi + ebx * 8 + 0]);
            mov(ecx, ptr[esi + ebx * 8 + 1]);
            mov(ecx, ptr[esi + ebx * 8 + 1000]);
            mov(ecx, ptr[esi + ebx * 8 - 1]);
            mov(ecx, ptr[esi + ebx * 8 - 1000]);
        }
    }

    class gen22 : CodeGenerator {
        this()
        {
            mov(ecx, ptr[esi + ebp + 0]);
            mov(ecx, ptr[esi + ebp + 1]);
            mov(ecx, ptr[esi + ebp + 1000]);
            mov(ecx, ptr[esi + ebp - 1]);
            mov(ecx, ptr[esi + ebp - 1000]);
            mov(ecx, ptr[esi + ebp * 1 + 0]);
            mov(ecx, ptr[esi + ebp * 1 + 1]);
            mov(ecx, ptr[esi + ebp * 1 + 1000]);
            mov(ecx, ptr[esi + ebp * 1 - 1]);
            mov(ecx, ptr[esi + ebp * 1 - 1000]);
            mov(ecx, ptr[esi + ebp * 2 + 0]);
            mov(ecx, ptr[esi + ebp * 2 + 1]);
            mov(ecx, ptr[esi + ebp * 2 + 1000]);
            mov(ecx, ptr[esi + ebp * 2 - 1]);
            mov(ecx, ptr[esi + ebp * 2 - 1000]);
            mov(ecx, ptr[esi + ebp * 4 + 0]);
            mov(ecx, ptr[esi + ebp * 4 + 1]);
            mov(ecx, ptr[esi + ebp * 4 + 1000]);
            mov(ecx, ptr[esi + ebp * 4 - 1]);
            mov(ecx, ptr[esi + ebp * 4 - 1000]);
            mov(ecx, ptr[esi + ebp * 8 + 0]);
            mov(ecx, ptr[esi + ebp * 8 + 1]);
            mov(ecx, ptr[esi + ebp * 8 + 1000]);
            mov(ecx, ptr[esi + ebp * 8 - 1]);
            mov(ecx, ptr[esi + ebp * 8 - 1000]);
            mov(ecx, ptr[esi + esi + 0]);
            mov(ecx, ptr[esi + esi + 1]);
            mov(ecx, ptr[esi + esi + 1000]);
            mov(ecx, ptr[esi + esi - 1]);
            mov(ecx, ptr[esi + esi - 1000]);
            mov(ecx, ptr[esi + esi * 1 + 0]);
            mov(ecx, ptr[esi + esi * 1 + 1]);
            mov(ecx, ptr[esi + esi * 1 + 1000]);
            mov(ecx, ptr[esi + esi * 1 - 1]);
            mov(ecx, ptr[esi + esi * 1 - 1000]);
            mov(ecx, ptr[esi + esi * 2 + 0]);
            mov(ecx, ptr[esi + esi * 2 + 1]);
            mov(ecx, ptr[esi + esi * 2 + 1000]);
            mov(ecx, ptr[esi + esi * 2 - 1]);
            mov(ecx, ptr[esi + esi * 2 - 1000]);
            mov(ecx, ptr[esi + esi * 4 + 0]);
            mov(ecx, ptr[esi + esi * 4 + 1]);
            mov(ecx, ptr[esi + esi * 4 + 1000]);
            mov(ecx, ptr[esi + esi * 4 - 1]);
            mov(ecx, ptr[esi + esi * 4 - 1000]);
            mov(ecx, ptr[esi + esi * 8 + 0]);
            mov(ecx, ptr[esi + esi * 8 + 1]);
            mov(ecx, ptr[esi + esi * 8 + 1000]);
            mov(ecx, ptr[esi + esi * 8 - 1]);
            mov(ecx, ptr[esi + esi * 8 - 1000]);
            mov(ecx, ptr[esi + edi + 0]);
            mov(ecx, ptr[esi + edi + 1]);
            mov(ecx, ptr[esi + edi + 1000]);
            mov(ecx, ptr[esi + edi - 1]);
            mov(ecx, ptr[esi + edi - 1000]);
            mov(ecx, ptr[esi + edi * 1 + 0]);
            mov(ecx, ptr[esi + edi * 1 + 1]);
            mov(ecx, ptr[esi + edi * 1 + 1000]);
            mov(ecx, ptr[esi + edi * 1 - 1]);
            mov(ecx, ptr[esi + edi * 1 - 1000]);
            mov(ecx, ptr[esi + edi * 2 + 0]);
            mov(ecx, ptr[esi + edi * 2 + 1]);
            mov(ecx, ptr[esi + edi * 2 + 1000]);
            mov(ecx, ptr[esi + edi * 2 - 1]);
            mov(ecx, ptr[esi + edi * 2 - 1000]);
            mov(ecx, ptr[esi + edi * 4 + 0]);
            mov(ecx, ptr[esi + edi * 4 + 1]);
            mov(ecx, ptr[esi + edi * 4 + 1000]);
            mov(ecx, ptr[esi + edi * 4 - 1]);
            mov(ecx, ptr[esi + edi * 4 - 1000]);
            mov(ecx, ptr[esi + edi * 8 + 0]);
            mov(ecx, ptr[esi + edi * 8 + 1]);
            mov(ecx, ptr[esi + edi * 8 + 1000]);
            mov(ecx, ptr[esi + edi * 8 - 1]);
            mov(ecx, ptr[esi + edi * 8 - 1000]);
            mov(ecx, ptr[esi + r9d + 0]);
            mov(ecx, ptr[esi + r9d + 1]);
            mov(ecx, ptr[esi + r9d + 1000]);
            mov(ecx, ptr[esi + r9d - 1]);
            mov(ecx, ptr[esi + r9d - 1000]);
            mov(ecx, ptr[esi + r9d * 1 + 0]);
            mov(ecx, ptr[esi + r9d * 1 + 1]);
            mov(ecx, ptr[esi + r9d * 1 + 1000]);
            mov(ecx, ptr[esi + r9d * 1 - 1]);
            mov(ecx, ptr[esi + r9d * 1 - 1000]);
            mov(ecx, ptr[esi + r9d * 2 + 0]);
            mov(ecx, ptr[esi + r9d * 2 + 1]);
            mov(ecx, ptr[esi + r9d * 2 + 1000]);
            mov(ecx, ptr[esi + r9d * 2 - 1]);
            mov(ecx, ptr[esi + r9d * 2 - 1000]);
            mov(ecx, ptr[esi + r9d * 4 + 0]);
            mov(ecx, ptr[esi + r9d * 4 + 1]);
            mov(ecx, ptr[esi + r9d * 4 + 1000]);
            mov(ecx, ptr[esi + r9d * 4 - 1]);
            mov(ecx, ptr[esi + r9d * 4 - 1000]);
            mov(ecx, ptr[esi + r9d * 8 + 0]);
            mov(ecx, ptr[esi + r9d * 8 + 1]);
            mov(ecx, ptr[esi + r9d * 8 + 1000]);
            mov(ecx, ptr[esi + r9d * 8 - 1]);
            mov(ecx, ptr[esi + r9d * 8 - 1000]);
        }
    }

    class gen23 : CodeGenerator {
        this()
        {
            mov(ecx, ptr[esi + r10d + 0]);
            mov(ecx, ptr[esi + r10d + 1]);
            mov(ecx, ptr[esi + r10d + 1000]);
            mov(ecx, ptr[esi + r10d - 1]);
            mov(ecx, ptr[esi + r10d - 1000]);
            mov(ecx, ptr[esi + r10d * 1 + 0]);
            mov(ecx, ptr[esi + r10d * 1 + 1]);
            mov(ecx, ptr[esi + r10d * 1 + 1000]);
            mov(ecx, ptr[esi + r10d * 1 - 1]);
            mov(ecx, ptr[esi + r10d * 1 - 1000]);
            mov(ecx, ptr[esi + r10d * 2 + 0]);
            mov(ecx, ptr[esi + r10d * 2 + 1]);
            mov(ecx, ptr[esi + r10d * 2 + 1000]);
            mov(ecx, ptr[esi + r10d * 2 - 1]);
            mov(ecx, ptr[esi + r10d * 2 - 1000]);
            mov(ecx, ptr[esi + r10d * 4 + 0]);
            mov(ecx, ptr[esi + r10d * 4 + 1]);
            mov(ecx, ptr[esi + r10d * 4 + 1000]);
            mov(ecx, ptr[esi + r10d * 4 - 1]);
            mov(ecx, ptr[esi + r10d * 4 - 1000]);
            mov(ecx, ptr[esi + r10d * 8 + 0]);
            mov(ecx, ptr[esi + r10d * 8 + 1]);
            mov(ecx, ptr[esi + r10d * 8 + 1000]);
            mov(ecx, ptr[esi + r10d * 8 - 1]);
            mov(ecx, ptr[esi + r10d * 8 - 1000]);
            mov(ecx, ptr[esi + r11d + 0]);
            mov(ecx, ptr[esi + r11d + 1]);
            mov(ecx, ptr[esi + r11d + 1000]);
            mov(ecx, ptr[esi + r11d - 1]);
            mov(ecx, ptr[esi + r11d - 1000]);
            mov(ecx, ptr[esi + r11d * 1 + 0]);
            mov(ecx, ptr[esi + r11d * 1 + 1]);
            mov(ecx, ptr[esi + r11d * 1 + 1000]);
            mov(ecx, ptr[esi + r11d * 1 - 1]);
            mov(ecx, ptr[esi + r11d * 1 - 1000]);
            mov(ecx, ptr[esi + r11d * 2 + 0]);
            mov(ecx, ptr[esi + r11d * 2 + 1]);
            mov(ecx, ptr[esi + r11d * 2 + 1000]);
            mov(ecx, ptr[esi + r11d * 2 - 1]);
            mov(ecx, ptr[esi + r11d * 2 - 1000]);
            mov(ecx, ptr[esi + r11d * 4 + 0]);
            mov(ecx, ptr[esi + r11d * 4 + 1]);
            mov(ecx, ptr[esi + r11d * 4 + 1000]);
            mov(ecx, ptr[esi + r11d * 4 - 1]);
            mov(ecx, ptr[esi + r11d * 4 - 1000]);
            mov(ecx, ptr[esi + r11d * 8 + 0]);
            mov(ecx, ptr[esi + r11d * 8 + 1]);
            mov(ecx, ptr[esi + r11d * 8 + 1000]);
            mov(ecx, ptr[esi + r11d * 8 - 1]);
            mov(ecx, ptr[esi + r11d * 8 - 1000]);
            mov(ecx, ptr[esi + r12d + 0]);
            mov(ecx, ptr[esi + r12d + 1]);
            mov(ecx, ptr[esi + r12d + 1000]);
            mov(ecx, ptr[esi + r12d - 1]);
            mov(ecx, ptr[esi + r12d - 1000]);
            mov(ecx, ptr[esi + r12d * 1 + 0]);
            mov(ecx, ptr[esi + r12d * 1 + 1]);
            mov(ecx, ptr[esi + r12d * 1 + 1000]);
            mov(ecx, ptr[esi + r12d * 1 - 1]);
            mov(ecx, ptr[esi + r12d * 1 - 1000]);
            mov(ecx, ptr[esi + r12d * 2 + 0]);
            mov(ecx, ptr[esi + r12d * 2 + 1]);
            mov(ecx, ptr[esi + r12d * 2 + 1000]);
            mov(ecx, ptr[esi + r12d * 2 - 1]);
            mov(ecx, ptr[esi + r12d * 2 - 1000]);
            mov(ecx, ptr[esi + r12d * 4 + 0]);
            mov(ecx, ptr[esi + r12d * 4 + 1]);
            mov(ecx, ptr[esi + r12d * 4 + 1000]);
            mov(ecx, ptr[esi + r12d * 4 - 1]);
            mov(ecx, ptr[esi + r12d * 4 - 1000]);
            mov(ecx, ptr[esi + r12d * 8 + 0]);
            mov(ecx, ptr[esi + r12d * 8 + 1]);
            mov(ecx, ptr[esi + r12d * 8 + 1000]);
            mov(ecx, ptr[esi + r12d * 8 - 1]);
            mov(ecx, ptr[esi + r12d * 8 - 1000]);
            mov(ecx, ptr[esi + r13d + 0]);
            mov(ecx, ptr[esi + r13d + 1]);
            mov(ecx, ptr[esi + r13d + 1000]);
            mov(ecx, ptr[esi + r13d - 1]);
            mov(ecx, ptr[esi + r13d - 1000]);
            mov(ecx, ptr[esi + r13d * 1 + 0]);
            mov(ecx, ptr[esi + r13d * 1 + 1]);
            mov(ecx, ptr[esi + r13d * 1 + 1000]);
            mov(ecx, ptr[esi + r13d * 1 - 1]);
            mov(ecx, ptr[esi + r13d * 1 - 1000]);
            mov(ecx, ptr[esi + r13d * 2 + 0]);
            mov(ecx, ptr[esi + r13d * 2 + 1]);
            mov(ecx, ptr[esi + r13d * 2 + 1000]);
            mov(ecx, ptr[esi + r13d * 2 - 1]);
            mov(ecx, ptr[esi + r13d * 2 - 1000]);
            mov(ecx, ptr[esi + r13d * 4 + 0]);
            mov(ecx, ptr[esi + r13d * 4 + 1]);
            mov(ecx, ptr[esi + r13d * 4 + 1000]);
            mov(ecx, ptr[esi + r13d * 4 - 1]);
            mov(ecx, ptr[esi + r13d * 4 - 1000]);
            mov(ecx, ptr[esi + r13d * 8 + 0]);
            mov(ecx, ptr[esi + r13d * 8 + 1]);
            mov(ecx, ptr[esi + r13d * 8 + 1000]);
            mov(ecx, ptr[esi + r13d * 8 - 1]);
            mov(ecx, ptr[esi + r13d * 8 - 1000]);
        }
    }

    class gen24 : CodeGenerator {
        this()
        {
            mov(ecx, ptr[esi + r14d + 0]);
            mov(ecx, ptr[esi + r14d + 1]);
            mov(ecx, ptr[esi + r14d + 1000]);
            mov(ecx, ptr[esi + r14d - 1]);
            mov(ecx, ptr[esi + r14d - 1000]);
            mov(ecx, ptr[esi + r14d * 1 + 0]);
            mov(ecx, ptr[esi + r14d * 1 + 1]);
            mov(ecx, ptr[esi + r14d * 1 + 1000]);
            mov(ecx, ptr[esi + r14d * 1 - 1]);
            mov(ecx, ptr[esi + r14d * 1 - 1000]);
            mov(ecx, ptr[esi + r14d * 2 + 0]);
            mov(ecx, ptr[esi + r14d * 2 + 1]);
            mov(ecx, ptr[esi + r14d * 2 + 1000]);
            mov(ecx, ptr[esi + r14d * 2 - 1]);
            mov(ecx, ptr[esi + r14d * 2 - 1000]);
            mov(ecx, ptr[esi + r14d * 4 + 0]);
            mov(ecx, ptr[esi + r14d * 4 + 1]);
            mov(ecx, ptr[esi + r14d * 4 + 1000]);
            mov(ecx, ptr[esi + r14d * 4 - 1]);
            mov(ecx, ptr[esi + r14d * 4 - 1000]);
            mov(ecx, ptr[esi + r14d * 8 + 0]);
            mov(ecx, ptr[esi + r14d * 8 + 1]);
            mov(ecx, ptr[esi + r14d * 8 + 1000]);
            mov(ecx, ptr[esi + r14d * 8 - 1]);
            mov(ecx, ptr[esi + r14d * 8 - 1000]);
            mov(ecx, ptr[esi + r15d + 0]);
            mov(ecx, ptr[esi + r15d + 1]);
            mov(ecx, ptr[esi + r15d + 1000]);
            mov(ecx, ptr[esi + r15d - 1]);
            mov(ecx, ptr[esi + r15d - 1000]);
            mov(ecx, ptr[esi + r15d * 1 + 0]);
            mov(ecx, ptr[esi + r15d * 1 + 1]);
            mov(ecx, ptr[esi + r15d * 1 + 1000]);
            mov(ecx, ptr[esi + r15d * 1 - 1]);
            mov(ecx, ptr[esi + r15d * 1 - 1000]);
            mov(ecx, ptr[esi + r15d * 2 + 0]);
            mov(ecx, ptr[esi + r15d * 2 + 1]);
            mov(ecx, ptr[esi + r15d * 2 + 1000]);
            mov(ecx, ptr[esi + r15d * 2 - 1]);
            mov(ecx, ptr[esi + r15d * 2 - 1000]);
            mov(ecx, ptr[esi + r15d * 4 + 0]);
            mov(ecx, ptr[esi + r15d * 4 + 1]);
            mov(ecx, ptr[esi + r15d * 4 + 1000]);
            mov(ecx, ptr[esi + r15d * 4 - 1]);
            mov(ecx, ptr[esi + r15d * 4 - 1000]);
            mov(ecx, ptr[esi + r15d * 8 + 0]);
            mov(ecx, ptr[esi + r15d * 8 + 1]);
            mov(ecx, ptr[esi + r15d * 8 + 1000]);
            mov(ecx, ptr[esi + r15d * 8 - 1]);
            mov(ecx, ptr[esi + r15d * 8 - 1000]);
            mov(ecx, ptr[edi + eax + 0]);
            mov(ecx, ptr[edi + eax + 1]);
            mov(ecx, ptr[edi + eax + 1000]);
            mov(ecx, ptr[edi + eax - 1]);
            mov(ecx, ptr[edi + eax - 1000]);
            mov(ecx, ptr[edi + eax * 1 + 0]);
            mov(ecx, ptr[edi + eax * 1 + 1]);
            mov(ecx, ptr[edi + eax * 1 + 1000]);
            mov(ecx, ptr[edi + eax * 1 - 1]);
            mov(ecx, ptr[edi + eax * 1 - 1000]);
            mov(ecx, ptr[edi + eax * 2 + 0]);
            mov(ecx, ptr[edi + eax * 2 + 1]);
            mov(ecx, ptr[edi + eax * 2 + 1000]);
            mov(ecx, ptr[edi + eax * 2 - 1]);
            mov(ecx, ptr[edi + eax * 2 - 1000]);
            mov(ecx, ptr[edi + eax * 4 + 0]);
            mov(ecx, ptr[edi + eax * 4 + 1]);
            mov(ecx, ptr[edi + eax * 4 + 1000]);
            mov(ecx, ptr[edi + eax * 4 - 1]);
            mov(ecx, ptr[edi + eax * 4 - 1000]);
            mov(ecx, ptr[edi + eax * 8 + 0]);
            mov(ecx, ptr[edi + eax * 8 + 1]);
            mov(ecx, ptr[edi + eax * 8 + 1000]);
            mov(ecx, ptr[edi + eax * 8 - 1]);
            mov(ecx, ptr[edi + eax * 8 - 1000]);
            mov(ecx, ptr[edi + ecx + 0]);
            mov(ecx, ptr[edi + ecx + 1]);
            mov(ecx, ptr[edi + ecx + 1000]);
            mov(ecx, ptr[edi + ecx - 1]);
            mov(ecx, ptr[edi + ecx - 1000]);
            mov(ecx, ptr[edi + ecx * 1 + 0]);
            mov(ecx, ptr[edi + ecx * 1 + 1]);
            mov(ecx, ptr[edi + ecx * 1 + 1000]);
            mov(ecx, ptr[edi + ecx * 1 - 1]);
            mov(ecx, ptr[edi + ecx * 1 - 1000]);
            mov(ecx, ptr[edi + ecx * 2 + 0]);
            mov(ecx, ptr[edi + ecx * 2 + 1]);
            mov(ecx, ptr[edi + ecx * 2 + 1000]);
            mov(ecx, ptr[edi + ecx * 2 - 1]);
            mov(ecx, ptr[edi + ecx * 2 - 1000]);
            mov(ecx, ptr[edi + ecx * 4 + 0]);
            mov(ecx, ptr[edi + ecx * 4 + 1]);
            mov(ecx, ptr[edi + ecx * 4 + 1000]);
            mov(ecx, ptr[edi + ecx * 4 - 1]);
            mov(ecx, ptr[edi + ecx * 4 - 1000]);
            mov(ecx, ptr[edi + ecx * 8 + 0]);
            mov(ecx, ptr[edi + ecx * 8 + 1]);
            mov(ecx, ptr[edi + ecx * 8 + 1000]);
            mov(ecx, ptr[edi + ecx * 8 - 1]);
            mov(ecx, ptr[edi + ecx * 8 - 1000]);
        }
    }

    class gen25 : CodeGenerator {
        this()
        {
            mov(ecx, ptr[edi + edx + 0]);
            mov(ecx, ptr[edi + edx + 1]);
            mov(ecx, ptr[edi + edx + 1000]);
            mov(ecx, ptr[edi + edx - 1]);
            mov(ecx, ptr[edi + edx - 1000]);
            mov(ecx, ptr[edi + edx * 1 + 0]);
            mov(ecx, ptr[edi + edx * 1 + 1]);
            mov(ecx, ptr[edi + edx * 1 + 1000]);
            mov(ecx, ptr[edi + edx * 1 - 1]);
            mov(ecx, ptr[edi + edx * 1 - 1000]);
            mov(ecx, ptr[edi + edx * 2 + 0]);
            mov(ecx, ptr[edi + edx * 2 + 1]);
            mov(ecx, ptr[edi + edx * 2 + 1000]);
            mov(ecx, ptr[edi + edx * 2 - 1]);
            mov(ecx, ptr[edi + edx * 2 - 1000]);
            mov(ecx, ptr[edi + edx * 4 + 0]);
            mov(ecx, ptr[edi + edx * 4 + 1]);
            mov(ecx, ptr[edi + edx * 4 + 1000]);
            mov(ecx, ptr[edi + edx * 4 - 1]);
            mov(ecx, ptr[edi + edx * 4 - 1000]);
            mov(ecx, ptr[edi + edx * 8 + 0]);
            mov(ecx, ptr[edi + edx * 8 + 1]);
            mov(ecx, ptr[edi + edx * 8 + 1000]);
            mov(ecx, ptr[edi + edx * 8 - 1]);
            mov(ecx, ptr[edi + edx * 8 - 1000]);
            mov(ecx, ptr[edi + ebx + 0]);
            mov(ecx, ptr[edi + ebx + 1]);
            mov(ecx, ptr[edi + ebx + 1000]);
            mov(ecx, ptr[edi + ebx - 1]);
            mov(ecx, ptr[edi + ebx - 1000]);
            mov(ecx, ptr[edi + ebx * 1 + 0]);
            mov(ecx, ptr[edi + ebx * 1 + 1]);
            mov(ecx, ptr[edi + ebx * 1 + 1000]);
            mov(ecx, ptr[edi + ebx * 1 - 1]);
            mov(ecx, ptr[edi + ebx * 1 - 1000]);
            mov(ecx, ptr[edi + ebx * 2 + 0]);
            mov(ecx, ptr[edi + ebx * 2 + 1]);
            mov(ecx, ptr[edi + ebx * 2 + 1000]);
            mov(ecx, ptr[edi + ebx * 2 - 1]);
            mov(ecx, ptr[edi + ebx * 2 - 1000]);
            mov(ecx, ptr[edi + ebx * 4 + 0]);
            mov(ecx, ptr[edi + ebx * 4 + 1]);
            mov(ecx, ptr[edi + ebx * 4 + 1000]);
            mov(ecx, ptr[edi + ebx * 4 - 1]);
            mov(ecx, ptr[edi + ebx * 4 - 1000]);
            mov(ecx, ptr[edi + ebx * 8 + 0]);
            mov(ecx, ptr[edi + ebx * 8 + 1]);
            mov(ecx, ptr[edi + ebx * 8 + 1000]);
            mov(ecx, ptr[edi + ebx * 8 - 1]);
            mov(ecx, ptr[edi + ebx * 8 - 1000]);
            mov(ecx, ptr[edi + ebp + 0]);
            mov(ecx, ptr[edi + ebp + 1]);
            mov(ecx, ptr[edi + ebp + 1000]);
            mov(ecx, ptr[edi + ebp - 1]);
            mov(ecx, ptr[edi + ebp - 1000]);
            mov(ecx, ptr[edi + ebp * 1 + 0]);
            mov(ecx, ptr[edi + ebp * 1 + 1]);
            mov(ecx, ptr[edi + ebp * 1 + 1000]);
            mov(ecx, ptr[edi + ebp * 1 - 1]);
            mov(ecx, ptr[edi + ebp * 1 - 1000]);
            mov(ecx, ptr[edi + ebp * 2 + 0]);
            mov(ecx, ptr[edi + ebp * 2 + 1]);
            mov(ecx, ptr[edi + ebp * 2 + 1000]);
            mov(ecx, ptr[edi + ebp * 2 - 1]);
            mov(ecx, ptr[edi + ebp * 2 - 1000]);
            mov(ecx, ptr[edi + ebp * 4 + 0]);
            mov(ecx, ptr[edi + ebp * 4 + 1]);
            mov(ecx, ptr[edi + ebp * 4 + 1000]);
            mov(ecx, ptr[edi + ebp * 4 - 1]);
            mov(ecx, ptr[edi + ebp * 4 - 1000]);
            mov(ecx, ptr[edi + ebp * 8 + 0]);
            mov(ecx, ptr[edi + ebp * 8 + 1]);
            mov(ecx, ptr[edi + ebp * 8 + 1000]);
            mov(ecx, ptr[edi + ebp * 8 - 1]);
            mov(ecx, ptr[edi + ebp * 8 - 1000]);
            mov(ecx, ptr[edi + esi + 0]);
            mov(ecx, ptr[edi + esi + 1]);
            mov(ecx, ptr[edi + esi + 1000]);
            mov(ecx, ptr[edi + esi - 1]);
            mov(ecx, ptr[edi + esi - 1000]);
            mov(ecx, ptr[edi + esi * 1 + 0]);
            mov(ecx, ptr[edi + esi * 1 + 1]);
            mov(ecx, ptr[edi + esi * 1 + 1000]);
            mov(ecx, ptr[edi + esi * 1 - 1]);
            mov(ecx, ptr[edi + esi * 1 - 1000]);
            mov(ecx, ptr[edi + esi * 2 + 0]);
            mov(ecx, ptr[edi + esi * 2 + 1]);
            mov(ecx, ptr[edi + esi * 2 + 1000]);
            mov(ecx, ptr[edi + esi * 2 - 1]);
            mov(ecx, ptr[edi + esi * 2 - 1000]);
            mov(ecx, ptr[edi + esi * 4 + 0]);
            mov(ecx, ptr[edi + esi * 4 + 1]);
            mov(ecx, ptr[edi + esi * 4 + 1000]);
            mov(ecx, ptr[edi + esi * 4 - 1]);
            mov(ecx, ptr[edi + esi * 4 - 1000]);
            mov(ecx, ptr[edi + esi * 8 + 0]);
            mov(ecx, ptr[edi + esi * 8 + 1]);
            mov(ecx, ptr[edi + esi * 8 + 1000]);
            mov(ecx, ptr[edi + esi * 8 - 1]);
            mov(ecx, ptr[edi + esi * 8 - 1000]);
        }
    }

    class gen26 : CodeGenerator {
        this()
        {
            mov(ecx, ptr[edi + edi + 0]);
            mov(ecx, ptr[edi + edi + 1]);
            mov(ecx, ptr[edi + edi + 1000]);
            mov(ecx, ptr[edi + edi - 1]);
            mov(ecx, ptr[edi + edi - 1000]);
            mov(ecx, ptr[edi + edi * 1 + 0]);
            mov(ecx, ptr[edi + edi * 1 + 1]);
            mov(ecx, ptr[edi + edi * 1 + 1000]);
            mov(ecx, ptr[edi + edi * 1 - 1]);
            mov(ecx, ptr[edi + edi * 1 - 1000]);
            mov(ecx, ptr[edi + edi * 2 + 0]);
            mov(ecx, ptr[edi + edi * 2 + 1]);
            mov(ecx, ptr[edi + edi * 2 + 1000]);
            mov(ecx, ptr[edi + edi * 2 - 1]);
            mov(ecx, ptr[edi + edi * 2 - 1000]);
            mov(ecx, ptr[edi + edi * 4 + 0]);
            mov(ecx, ptr[edi + edi * 4 + 1]);
            mov(ecx, ptr[edi + edi * 4 + 1000]);
            mov(ecx, ptr[edi + edi * 4 - 1]);
            mov(ecx, ptr[edi + edi * 4 - 1000]);
            mov(ecx, ptr[edi + edi * 8 + 0]);
            mov(ecx, ptr[edi + edi * 8 + 1]);
            mov(ecx, ptr[edi + edi * 8 + 1000]);
            mov(ecx, ptr[edi + edi * 8 - 1]);
            mov(ecx, ptr[edi + edi * 8 - 1000]);
            mov(ecx, ptr[edi + r9d + 0]);
            mov(ecx, ptr[edi + r9d + 1]);
            mov(ecx, ptr[edi + r9d + 1000]);
            mov(ecx, ptr[edi + r9d - 1]);
            mov(ecx, ptr[edi + r9d - 1000]);
            mov(ecx, ptr[edi + r9d * 1 + 0]);
            mov(ecx, ptr[edi + r9d * 1 + 1]);
            mov(ecx, ptr[edi + r9d * 1 + 1000]);
            mov(ecx, ptr[edi + r9d * 1 - 1]);
            mov(ecx, ptr[edi + r9d * 1 - 1000]);
            mov(ecx, ptr[edi + r9d * 2 + 0]);
            mov(ecx, ptr[edi + r9d * 2 + 1]);
            mov(ecx, ptr[edi + r9d * 2 + 1000]);
            mov(ecx, ptr[edi + r9d * 2 - 1]);
            mov(ecx, ptr[edi + r9d * 2 - 1000]);
            mov(ecx, ptr[edi + r9d * 4 + 0]);
            mov(ecx, ptr[edi + r9d * 4 + 1]);
            mov(ecx, ptr[edi + r9d * 4 + 1000]);
            mov(ecx, ptr[edi + r9d * 4 - 1]);
            mov(ecx, ptr[edi + r9d * 4 - 1000]);
            mov(ecx, ptr[edi + r9d * 8 + 0]);
            mov(ecx, ptr[edi + r9d * 8 + 1]);
            mov(ecx, ptr[edi + r9d * 8 + 1000]);
            mov(ecx, ptr[edi + r9d * 8 - 1]);
            mov(ecx, ptr[edi + r9d * 8 - 1000]);
            mov(ecx, ptr[edi + r10d + 0]);
            mov(ecx, ptr[edi + r10d + 1]);
            mov(ecx, ptr[edi + r10d + 1000]);
            mov(ecx, ptr[edi + r10d - 1]);
            mov(ecx, ptr[edi + r10d - 1000]);
            mov(ecx, ptr[edi + r10d * 1 + 0]);
            mov(ecx, ptr[edi + r10d * 1 + 1]);
            mov(ecx, ptr[edi + r10d * 1 + 1000]);
            mov(ecx, ptr[edi + r10d * 1 - 1]);
            mov(ecx, ptr[edi + r10d * 1 - 1000]);
            mov(ecx, ptr[edi + r10d * 2 + 0]);
            mov(ecx, ptr[edi + r10d * 2 + 1]);
            mov(ecx, ptr[edi + r10d * 2 + 1000]);
            mov(ecx, ptr[edi + r10d * 2 - 1]);
            mov(ecx, ptr[edi + r10d * 2 - 1000]);
            mov(ecx, ptr[edi + r10d * 4 + 0]);
            mov(ecx, ptr[edi + r10d * 4 + 1]);
            mov(ecx, ptr[edi + r10d * 4 + 1000]);
            mov(ecx, ptr[edi + r10d * 4 - 1]);
            mov(ecx, ptr[edi + r10d * 4 - 1000]);
            mov(ecx, ptr[edi + r10d * 8 + 0]);
            mov(ecx, ptr[edi + r10d * 8 + 1]);
            mov(ecx, ptr[edi + r10d * 8 + 1000]);
            mov(ecx, ptr[edi + r10d * 8 - 1]);
            mov(ecx, ptr[edi + r10d * 8 - 1000]);
            mov(ecx, ptr[edi + r11d + 0]);
            mov(ecx, ptr[edi + r11d + 1]);
            mov(ecx, ptr[edi + r11d + 1000]);
            mov(ecx, ptr[edi + r11d - 1]);
            mov(ecx, ptr[edi + r11d - 1000]);
            mov(ecx, ptr[edi + r11d * 1 + 0]);
            mov(ecx, ptr[edi + r11d * 1 + 1]);
            mov(ecx, ptr[edi + r11d * 1 + 1000]);
            mov(ecx, ptr[edi + r11d * 1 - 1]);
            mov(ecx, ptr[edi + r11d * 1 - 1000]);
            mov(ecx, ptr[edi + r11d * 2 + 0]);
            mov(ecx, ptr[edi + r11d * 2 + 1]);
            mov(ecx, ptr[edi + r11d * 2 + 1000]);
            mov(ecx, ptr[edi + r11d * 2 - 1]);
            mov(ecx, ptr[edi + r11d * 2 - 1000]);
            mov(ecx, ptr[edi + r11d * 4 + 0]);
            mov(ecx, ptr[edi + r11d * 4 + 1]);
            mov(ecx, ptr[edi + r11d * 4 + 1000]);
            mov(ecx, ptr[edi + r11d * 4 - 1]);
            mov(ecx, ptr[edi + r11d * 4 - 1000]);
            mov(ecx, ptr[edi + r11d * 8 + 0]);
            mov(ecx, ptr[edi + r11d * 8 + 1]);
            mov(ecx, ptr[edi + r11d * 8 + 1000]);
            mov(ecx, ptr[edi + r11d * 8 - 1]);
            mov(ecx, ptr[edi + r11d * 8 - 1000]);
        }
    }

    class gen27 : CodeGenerator {
        this()
        {
            mov(ecx, ptr[edi + r12d + 0]);
            mov(ecx, ptr[edi + r12d + 1]);
            mov(ecx, ptr[edi + r12d + 1000]);
            mov(ecx, ptr[edi + r12d - 1]);
            mov(ecx, ptr[edi + r12d - 1000]);
            mov(ecx, ptr[edi + r12d * 1 + 0]);
            mov(ecx, ptr[edi + r12d * 1 + 1]);
            mov(ecx, ptr[edi + r12d * 1 + 1000]);
            mov(ecx, ptr[edi + r12d * 1 - 1]);
            mov(ecx, ptr[edi + r12d * 1 - 1000]);
            mov(ecx, ptr[edi + r12d * 2 + 0]);
            mov(ecx, ptr[edi + r12d * 2 + 1]);
            mov(ecx, ptr[edi + r12d * 2 + 1000]);
            mov(ecx, ptr[edi + r12d * 2 - 1]);
            mov(ecx, ptr[edi + r12d * 2 - 1000]);
            mov(ecx, ptr[edi + r12d * 4 + 0]);
            mov(ecx, ptr[edi + r12d * 4 + 1]);
            mov(ecx, ptr[edi + r12d * 4 + 1000]);
            mov(ecx, ptr[edi + r12d * 4 - 1]);
            mov(ecx, ptr[edi + r12d * 4 - 1000]);
            mov(ecx, ptr[edi + r12d * 8 + 0]);
            mov(ecx, ptr[edi + r12d * 8 + 1]);
            mov(ecx, ptr[edi + r12d * 8 + 1000]);
            mov(ecx, ptr[edi + r12d * 8 - 1]);
            mov(ecx, ptr[edi + r12d * 8 - 1000]);
            mov(ecx, ptr[edi + r13d + 0]);
            mov(ecx, ptr[edi + r13d + 1]);
            mov(ecx, ptr[edi + r13d + 1000]);
            mov(ecx, ptr[edi + r13d - 1]);
            mov(ecx, ptr[edi + r13d - 1000]);
            mov(ecx, ptr[edi + r13d * 1 + 0]);
            mov(ecx, ptr[edi + r13d * 1 + 1]);
            mov(ecx, ptr[edi + r13d * 1 + 1000]);
            mov(ecx, ptr[edi + r13d * 1 - 1]);
            mov(ecx, ptr[edi + r13d * 1 - 1000]);
            mov(ecx, ptr[edi + r13d * 2 + 0]);
            mov(ecx, ptr[edi + r13d * 2 + 1]);
            mov(ecx, ptr[edi + r13d * 2 + 1000]);
            mov(ecx, ptr[edi + r13d * 2 - 1]);
            mov(ecx, ptr[edi + r13d * 2 - 1000]);
            mov(ecx, ptr[edi + r13d * 4 + 0]);
            mov(ecx, ptr[edi + r13d * 4 + 1]);
            mov(ecx, ptr[edi + r13d * 4 + 1000]);
            mov(ecx, ptr[edi + r13d * 4 - 1]);
            mov(ecx, ptr[edi + r13d * 4 - 1000]);
            mov(ecx, ptr[edi + r13d * 8 + 0]);
            mov(ecx, ptr[edi + r13d * 8 + 1]);
            mov(ecx, ptr[edi + r13d * 8 + 1000]);
            mov(ecx, ptr[edi + r13d * 8 - 1]);
            mov(ecx, ptr[edi + r13d * 8 - 1000]);
            mov(ecx, ptr[edi + r14d + 0]);
            mov(ecx, ptr[edi + r14d + 1]);
            mov(ecx, ptr[edi + r14d + 1000]);
            mov(ecx, ptr[edi + r14d - 1]);
            mov(ecx, ptr[edi + r14d - 1000]);
            mov(ecx, ptr[edi + r14d * 1 + 0]);
            mov(ecx, ptr[edi + r14d * 1 + 1]);
            mov(ecx, ptr[edi + r14d * 1 + 1000]);
            mov(ecx, ptr[edi + r14d * 1 - 1]);
            mov(ecx, ptr[edi + r14d * 1 - 1000]);
            mov(ecx, ptr[edi + r14d * 2 + 0]);
            mov(ecx, ptr[edi + r14d * 2 + 1]);
            mov(ecx, ptr[edi + r14d * 2 + 1000]);
            mov(ecx, ptr[edi + r14d * 2 - 1]);
            mov(ecx, ptr[edi + r14d * 2 - 1000]);
            mov(ecx, ptr[edi + r14d * 4 + 0]);
            mov(ecx, ptr[edi + r14d * 4 + 1]);
            mov(ecx, ptr[edi + r14d * 4 + 1000]);
            mov(ecx, ptr[edi + r14d * 4 - 1]);
            mov(ecx, ptr[edi + r14d * 4 - 1000]);
            mov(ecx, ptr[edi + r14d * 8 + 0]);
            mov(ecx, ptr[edi + r14d * 8 + 1]);
            mov(ecx, ptr[edi + r14d * 8 + 1000]);
            mov(ecx, ptr[edi + r14d * 8 - 1]);
            mov(ecx, ptr[edi + r14d * 8 - 1000]);
            mov(ecx, ptr[edi + r15d + 0]);
            mov(ecx, ptr[edi + r15d + 1]);
            mov(ecx, ptr[edi + r15d + 1000]);
            mov(ecx, ptr[edi + r15d - 1]);
            mov(ecx, ptr[edi + r15d - 1000]);
            mov(ecx, ptr[edi + r15d * 1 + 0]);
            mov(ecx, ptr[edi + r15d * 1 + 1]);
            mov(ecx, ptr[edi + r15d * 1 + 1000]);
            mov(ecx, ptr[edi + r15d * 1 - 1]);
            mov(ecx, ptr[edi + r15d * 1 - 1000]);
            mov(ecx, ptr[edi + r15d * 2 + 0]);
            mov(ecx, ptr[edi + r15d * 2 + 1]);
            mov(ecx, ptr[edi + r15d * 2 + 1000]);
            mov(ecx, ptr[edi + r15d * 2 - 1]);
            mov(ecx, ptr[edi + r15d * 2 - 1000]);
            mov(ecx, ptr[edi + r15d * 4 + 0]);
            mov(ecx, ptr[edi + r15d * 4 + 1]);
            mov(ecx, ptr[edi + r15d * 4 + 1000]);
            mov(ecx, ptr[edi + r15d * 4 - 1]);
            mov(ecx, ptr[edi + r15d * 4 - 1000]);
            mov(ecx, ptr[edi + r15d * 8 + 0]);
            mov(ecx, ptr[edi + r15d * 8 + 1]);
            mov(ecx, ptr[edi + r15d * 8 + 1000]);
            mov(ecx, ptr[edi + r15d * 8 - 1]);
            mov(ecx, ptr[edi + r15d * 8 - 1000]);
        }
    }

    class gen28 : CodeGenerator {
        this()
        {
            mov(ecx, ptr[r9d + eax + 0]);
            mov(ecx, ptr[r9d + eax + 1]);
            mov(ecx, ptr[r9d + eax + 1000]);
            mov(ecx, ptr[r9d + eax - 1]);
            mov(ecx, ptr[r9d + eax - 1000]);
            mov(ecx, ptr[r9d + eax * 1 + 0]);
            mov(ecx, ptr[r9d + eax * 1 + 1]);
            mov(ecx, ptr[r9d + eax * 1 + 1000]);
            mov(ecx, ptr[r9d + eax * 1 - 1]);
            mov(ecx, ptr[r9d + eax * 1 - 1000]);
            mov(ecx, ptr[r9d + eax * 2 + 0]);
            mov(ecx, ptr[r9d + eax * 2 + 1]);
            mov(ecx, ptr[r9d + eax * 2 + 1000]);
            mov(ecx, ptr[r9d + eax * 2 - 1]);
            mov(ecx, ptr[r9d + eax * 2 - 1000]);
            mov(ecx, ptr[r9d + eax * 4 + 0]);
            mov(ecx, ptr[r9d + eax * 4 + 1]);
            mov(ecx, ptr[r9d + eax * 4 + 1000]);
            mov(ecx, ptr[r9d + eax * 4 - 1]);
            mov(ecx, ptr[r9d + eax * 4 - 1000]);
            mov(ecx, ptr[r9d + eax * 8 + 0]);
            mov(ecx, ptr[r9d + eax * 8 + 1]);
            mov(ecx, ptr[r9d + eax * 8 + 1000]);
            mov(ecx, ptr[r9d + eax * 8 - 1]);
            mov(ecx, ptr[r9d + eax * 8 - 1000]);
            mov(ecx, ptr[r9d + ecx + 0]);
            mov(ecx, ptr[r9d + ecx + 1]);
            mov(ecx, ptr[r9d + ecx + 1000]);
            mov(ecx, ptr[r9d + ecx - 1]);
            mov(ecx, ptr[r9d + ecx - 1000]);
            mov(ecx, ptr[r9d + ecx * 1 + 0]);
            mov(ecx, ptr[r9d + ecx * 1 + 1]);
            mov(ecx, ptr[r9d + ecx * 1 + 1000]);
            mov(ecx, ptr[r9d + ecx * 1 - 1]);
            mov(ecx, ptr[r9d + ecx * 1 - 1000]);
            mov(ecx, ptr[r9d + ecx * 2 + 0]);
            mov(ecx, ptr[r9d + ecx * 2 + 1]);
            mov(ecx, ptr[r9d + ecx * 2 + 1000]);
            mov(ecx, ptr[r9d + ecx * 2 - 1]);
            mov(ecx, ptr[r9d + ecx * 2 - 1000]);
            mov(ecx, ptr[r9d + ecx * 4 + 0]);
            mov(ecx, ptr[r9d + ecx * 4 + 1]);
            mov(ecx, ptr[r9d + ecx * 4 + 1000]);
            mov(ecx, ptr[r9d + ecx * 4 - 1]);
            mov(ecx, ptr[r9d + ecx * 4 - 1000]);
            mov(ecx, ptr[r9d + ecx * 8 + 0]);
            mov(ecx, ptr[r9d + ecx * 8 + 1]);
            mov(ecx, ptr[r9d + ecx * 8 + 1000]);
            mov(ecx, ptr[r9d + ecx * 8 - 1]);
            mov(ecx, ptr[r9d + ecx * 8 - 1000]);
            mov(ecx, ptr[r9d + edx + 0]);
            mov(ecx, ptr[r9d + edx + 1]);
            mov(ecx, ptr[r9d + edx + 1000]);
            mov(ecx, ptr[r9d + edx - 1]);
            mov(ecx, ptr[r9d + edx - 1000]);
            mov(ecx, ptr[r9d + edx * 1 + 0]);
            mov(ecx, ptr[r9d + edx * 1 + 1]);
            mov(ecx, ptr[r9d + edx * 1 + 1000]);
            mov(ecx, ptr[r9d + edx * 1 - 1]);
            mov(ecx, ptr[r9d + edx * 1 - 1000]);
            mov(ecx, ptr[r9d + edx * 2 + 0]);
            mov(ecx, ptr[r9d + edx * 2 + 1]);
            mov(ecx, ptr[r9d + edx * 2 + 1000]);
            mov(ecx, ptr[r9d + edx * 2 - 1]);
            mov(ecx, ptr[r9d + edx * 2 - 1000]);
            mov(ecx, ptr[r9d + edx * 4 + 0]);
            mov(ecx, ptr[r9d + edx * 4 + 1]);
            mov(ecx, ptr[r9d + edx * 4 + 1000]);
            mov(ecx, ptr[r9d + edx * 4 - 1]);
            mov(ecx, ptr[r9d + edx * 4 - 1000]);
            mov(ecx, ptr[r9d + edx * 8 + 0]);
            mov(ecx, ptr[r9d + edx * 8 + 1]);
            mov(ecx, ptr[r9d + edx * 8 + 1000]);
            mov(ecx, ptr[r9d + edx * 8 - 1]);
            mov(ecx, ptr[r9d + edx * 8 - 1000]);
            mov(ecx, ptr[r9d + ebx + 0]);
            mov(ecx, ptr[r9d + ebx + 1]);
            mov(ecx, ptr[r9d + ebx + 1000]);
            mov(ecx, ptr[r9d + ebx - 1]);
            mov(ecx, ptr[r9d + ebx - 1000]);
            mov(ecx, ptr[r9d + ebx * 1 + 0]);
            mov(ecx, ptr[r9d + ebx * 1 + 1]);
            mov(ecx, ptr[r9d + ebx * 1 + 1000]);
            mov(ecx, ptr[r9d + ebx * 1 - 1]);
            mov(ecx, ptr[r9d + ebx * 1 - 1000]);
            mov(ecx, ptr[r9d + ebx * 2 + 0]);
            mov(ecx, ptr[r9d + ebx * 2 + 1]);
            mov(ecx, ptr[r9d + ebx * 2 + 1000]);
            mov(ecx, ptr[r9d + ebx * 2 - 1]);
            mov(ecx, ptr[r9d + ebx * 2 - 1000]);
            mov(ecx, ptr[r9d + ebx * 4 + 0]);
            mov(ecx, ptr[r9d + ebx * 4 + 1]);
            mov(ecx, ptr[r9d + ebx * 4 + 1000]);
            mov(ecx, ptr[r9d + ebx * 4 - 1]);
            mov(ecx, ptr[r9d + ebx * 4 - 1000]);
            mov(ecx, ptr[r9d + ebx * 8 + 0]);
            mov(ecx, ptr[r9d + ebx * 8 + 1]);
            mov(ecx, ptr[r9d + ebx * 8 + 1000]);
            mov(ecx, ptr[r9d + ebx * 8 - 1]);
            mov(ecx, ptr[r9d + ebx * 8 - 1000]);
        }
    }

    class gen29 : CodeGenerator {
        this()
        {
            mov(ecx, ptr[r9d + ebp + 0]);
            mov(ecx, ptr[r9d + ebp + 1]);
            mov(ecx, ptr[r9d + ebp + 1000]);
            mov(ecx, ptr[r9d + ebp - 1]);
            mov(ecx, ptr[r9d + ebp - 1000]);
            mov(ecx, ptr[r9d + ebp * 1 + 0]);
            mov(ecx, ptr[r9d + ebp * 1 + 1]);
            mov(ecx, ptr[r9d + ebp * 1 + 1000]);
            mov(ecx, ptr[r9d + ebp * 1 - 1]);
            mov(ecx, ptr[r9d + ebp * 1 - 1000]);
            mov(ecx, ptr[r9d + ebp * 2 + 0]);
            mov(ecx, ptr[r9d + ebp * 2 + 1]);
            mov(ecx, ptr[r9d + ebp * 2 + 1000]);
            mov(ecx, ptr[r9d + ebp * 2 - 1]);
            mov(ecx, ptr[r9d + ebp * 2 - 1000]);
            mov(ecx, ptr[r9d + ebp * 4 + 0]);
            mov(ecx, ptr[r9d + ebp * 4 + 1]);
            mov(ecx, ptr[r9d + ebp * 4 + 1000]);
            mov(ecx, ptr[r9d + ebp * 4 - 1]);
            mov(ecx, ptr[r9d + ebp * 4 - 1000]);
            mov(ecx, ptr[r9d + ebp * 8 + 0]);
            mov(ecx, ptr[r9d + ebp * 8 + 1]);
            mov(ecx, ptr[r9d + ebp * 8 + 1000]);
            mov(ecx, ptr[r9d + ebp * 8 - 1]);
            mov(ecx, ptr[r9d + ebp * 8 - 1000]);
            mov(ecx, ptr[r9d + esi + 0]);
            mov(ecx, ptr[r9d + esi + 1]);
            mov(ecx, ptr[r9d + esi + 1000]);
            mov(ecx, ptr[r9d + esi - 1]);
            mov(ecx, ptr[r9d + esi - 1000]);
            mov(ecx, ptr[r9d + esi * 1 + 0]);
            mov(ecx, ptr[r9d + esi * 1 + 1]);
            mov(ecx, ptr[r9d + esi * 1 + 1000]);
            mov(ecx, ptr[r9d + esi * 1 - 1]);
            mov(ecx, ptr[r9d + esi * 1 - 1000]);
            mov(ecx, ptr[r9d + esi * 2 + 0]);
            mov(ecx, ptr[r9d + esi * 2 + 1]);
            mov(ecx, ptr[r9d + esi * 2 + 1000]);
            mov(ecx, ptr[r9d + esi * 2 - 1]);
            mov(ecx, ptr[r9d + esi * 2 - 1000]);
            mov(ecx, ptr[r9d + esi * 4 + 0]);
            mov(ecx, ptr[r9d + esi * 4 + 1]);
            mov(ecx, ptr[r9d + esi * 4 + 1000]);
            mov(ecx, ptr[r9d + esi * 4 - 1]);
            mov(ecx, ptr[r9d + esi * 4 - 1000]);
            mov(ecx, ptr[r9d + esi * 8 + 0]);
            mov(ecx, ptr[r9d + esi * 8 + 1]);
            mov(ecx, ptr[r9d + esi * 8 + 1000]);
            mov(ecx, ptr[r9d + esi * 8 - 1]);
            mov(ecx, ptr[r9d + esi * 8 - 1000]);
            mov(ecx, ptr[r9d + edi + 0]);
            mov(ecx, ptr[r9d + edi + 1]);
            mov(ecx, ptr[r9d + edi + 1000]);
            mov(ecx, ptr[r9d + edi - 1]);
            mov(ecx, ptr[r9d + edi - 1000]);
            mov(ecx, ptr[r9d + edi * 1 + 0]);
            mov(ecx, ptr[r9d + edi * 1 + 1]);
            mov(ecx, ptr[r9d + edi * 1 + 1000]);
            mov(ecx, ptr[r9d + edi * 1 - 1]);
            mov(ecx, ptr[r9d + edi * 1 - 1000]);
            mov(ecx, ptr[r9d + edi * 2 + 0]);
            mov(ecx, ptr[r9d + edi * 2 + 1]);
            mov(ecx, ptr[r9d + edi * 2 + 1000]);
            mov(ecx, ptr[r9d + edi * 2 - 1]);
            mov(ecx, ptr[r9d + edi * 2 - 1000]);
            mov(ecx, ptr[r9d + edi * 4 + 0]);
            mov(ecx, ptr[r9d + edi * 4 + 1]);
            mov(ecx, ptr[r9d + edi * 4 + 1000]);
            mov(ecx, ptr[r9d + edi * 4 - 1]);
            mov(ecx, ptr[r9d + edi * 4 - 1000]);
            mov(ecx, ptr[r9d + edi * 8 + 0]);
            mov(ecx, ptr[r9d + edi * 8 + 1]);
            mov(ecx, ptr[r9d + edi * 8 + 1000]);
            mov(ecx, ptr[r9d + edi * 8 - 1]);
            mov(ecx, ptr[r9d + edi * 8 - 1000]);
            mov(ecx, ptr[r9d + r9d + 0]);
            mov(ecx, ptr[r9d + r9d + 1]);
            mov(ecx, ptr[r9d + r9d + 1000]);
            mov(ecx, ptr[r9d + r9d - 1]);
            mov(ecx, ptr[r9d + r9d - 1000]);
            mov(ecx, ptr[r9d + r9d * 1 + 0]);
            mov(ecx, ptr[r9d + r9d * 1 + 1]);
            mov(ecx, ptr[r9d + r9d * 1 + 1000]);
            mov(ecx, ptr[r9d + r9d * 1 - 1]);
            mov(ecx, ptr[r9d + r9d * 1 - 1000]);
            mov(ecx, ptr[r9d + r9d * 2 + 0]);
            mov(ecx, ptr[r9d + r9d * 2 + 1]);
            mov(ecx, ptr[r9d + r9d * 2 + 1000]);
            mov(ecx, ptr[r9d + r9d * 2 - 1]);
            mov(ecx, ptr[r9d + r9d * 2 - 1000]);
            mov(ecx, ptr[r9d + r9d * 4 + 0]);
            mov(ecx, ptr[r9d + r9d * 4 + 1]);
            mov(ecx, ptr[r9d + r9d * 4 + 1000]);
            mov(ecx, ptr[r9d + r9d * 4 - 1]);
            mov(ecx, ptr[r9d + r9d * 4 - 1000]);
            mov(ecx, ptr[r9d + r9d * 8 + 0]);
            mov(ecx, ptr[r9d + r9d * 8 + 1]);
            mov(ecx, ptr[r9d + r9d * 8 + 1000]);
            mov(ecx, ptr[r9d + r9d * 8 - 1]);
            mov(ecx, ptr[r9d + r9d * 8 - 1000]);
        }
    }

    class gen30 : CodeGenerator {
        this()
        {
            mov(ecx, ptr[r9d + r10d + 0]);
            mov(ecx, ptr[r9d + r10d + 1]);
            mov(ecx, ptr[r9d + r10d + 1000]);
            mov(ecx, ptr[r9d + r10d - 1]);
            mov(ecx, ptr[r9d + r10d - 1000]);
            mov(ecx, ptr[r9d + r10d * 1 + 0]);
            mov(ecx, ptr[r9d + r10d * 1 + 1]);
            mov(ecx, ptr[r9d + r10d * 1 + 1000]);
            mov(ecx, ptr[r9d + r10d * 1 - 1]);
            mov(ecx, ptr[r9d + r10d * 1 - 1000]);
            mov(ecx, ptr[r9d + r10d * 2 + 0]);
            mov(ecx, ptr[r9d + r10d * 2 + 1]);
            mov(ecx, ptr[r9d + r10d * 2 + 1000]);
            mov(ecx, ptr[r9d + r10d * 2 - 1]);
            mov(ecx, ptr[r9d + r10d * 2 - 1000]);
            mov(ecx, ptr[r9d + r10d * 4 + 0]);
            mov(ecx, ptr[r9d + r10d * 4 + 1]);
            mov(ecx, ptr[r9d + r10d * 4 + 1000]);
            mov(ecx, ptr[r9d + r10d * 4 - 1]);
            mov(ecx, ptr[r9d + r10d * 4 - 1000]);
            mov(ecx, ptr[r9d + r10d * 8 + 0]);
            mov(ecx, ptr[r9d + r10d * 8 + 1]);
            mov(ecx, ptr[r9d + r10d * 8 + 1000]);
            mov(ecx, ptr[r9d + r10d * 8 - 1]);
            mov(ecx, ptr[r9d + r10d * 8 - 1000]);
            mov(ecx, ptr[r9d + r11d + 0]);
            mov(ecx, ptr[r9d + r11d + 1]);
            mov(ecx, ptr[r9d + r11d + 1000]);
            mov(ecx, ptr[r9d + r11d - 1]);
            mov(ecx, ptr[r9d + r11d - 1000]);
            mov(ecx, ptr[r9d + r11d * 1 + 0]);
            mov(ecx, ptr[r9d + r11d * 1 + 1]);
            mov(ecx, ptr[r9d + r11d * 1 + 1000]);
            mov(ecx, ptr[r9d + r11d * 1 - 1]);
            mov(ecx, ptr[r9d + r11d * 1 - 1000]);
            mov(ecx, ptr[r9d + r11d * 2 + 0]);
            mov(ecx, ptr[r9d + r11d * 2 + 1]);
            mov(ecx, ptr[r9d + r11d * 2 + 1000]);
            mov(ecx, ptr[r9d + r11d * 2 - 1]);
            mov(ecx, ptr[r9d + r11d * 2 - 1000]);
            mov(ecx, ptr[r9d + r11d * 4 + 0]);
            mov(ecx, ptr[r9d + r11d * 4 + 1]);
            mov(ecx, ptr[r9d + r11d * 4 + 1000]);
            mov(ecx, ptr[r9d + r11d * 4 - 1]);
            mov(ecx, ptr[r9d + r11d * 4 - 1000]);
            mov(ecx, ptr[r9d + r11d * 8 + 0]);
            mov(ecx, ptr[r9d + r11d * 8 + 1]);
            mov(ecx, ptr[r9d + r11d * 8 + 1000]);
            mov(ecx, ptr[r9d + r11d * 8 - 1]);
            mov(ecx, ptr[r9d + r11d * 8 - 1000]);
            mov(ecx, ptr[r9d + r12d + 0]);
            mov(ecx, ptr[r9d + r12d + 1]);
            mov(ecx, ptr[r9d + r12d + 1000]);
            mov(ecx, ptr[r9d + r12d - 1]);
            mov(ecx, ptr[r9d + r12d - 1000]);
            mov(ecx, ptr[r9d + r12d * 1 + 0]);
            mov(ecx, ptr[r9d + r12d * 1 + 1]);
            mov(ecx, ptr[r9d + r12d * 1 + 1000]);
            mov(ecx, ptr[r9d + r12d * 1 - 1]);
            mov(ecx, ptr[r9d + r12d * 1 - 1000]);
            mov(ecx, ptr[r9d + r12d * 2 + 0]);
            mov(ecx, ptr[r9d + r12d * 2 + 1]);
            mov(ecx, ptr[r9d + r12d * 2 + 1000]);
            mov(ecx, ptr[r9d + r12d * 2 - 1]);
            mov(ecx, ptr[r9d + r12d * 2 - 1000]);
            mov(ecx, ptr[r9d + r12d * 4 + 0]);
            mov(ecx, ptr[r9d + r12d * 4 + 1]);
            mov(ecx, ptr[r9d + r12d * 4 + 1000]);
            mov(ecx, ptr[r9d + r12d * 4 - 1]);
            mov(ecx, ptr[r9d + r12d * 4 - 1000]);
            mov(ecx, ptr[r9d + r12d * 8 + 0]);
            mov(ecx, ptr[r9d + r12d * 8 + 1]);
            mov(ecx, ptr[r9d + r12d * 8 + 1000]);
            mov(ecx, ptr[r9d + r12d * 8 - 1]);
            mov(ecx, ptr[r9d + r12d * 8 - 1000]);
            mov(ecx, ptr[r9d + r13d + 0]);
            mov(ecx, ptr[r9d + r13d + 1]);
            mov(ecx, ptr[r9d + r13d + 1000]);
            mov(ecx, ptr[r9d + r13d - 1]);
            mov(ecx, ptr[r9d + r13d - 1000]);
            mov(ecx, ptr[r9d + r13d * 1 + 0]);
            mov(ecx, ptr[r9d + r13d * 1 + 1]);
            mov(ecx, ptr[r9d + r13d * 1 + 1000]);
            mov(ecx, ptr[r9d + r13d * 1 - 1]);
            mov(ecx, ptr[r9d + r13d * 1 - 1000]);
            mov(ecx, ptr[r9d + r13d * 2 + 0]);
            mov(ecx, ptr[r9d + r13d * 2 + 1]);
            mov(ecx, ptr[r9d + r13d * 2 + 1000]);
            mov(ecx, ptr[r9d + r13d * 2 - 1]);
            mov(ecx, ptr[r9d + r13d * 2 - 1000]);
            mov(ecx, ptr[r9d + r13d * 4 + 0]);
            mov(ecx, ptr[r9d + r13d * 4 + 1]);
            mov(ecx, ptr[r9d + r13d * 4 + 1000]);
            mov(ecx, ptr[r9d + r13d * 4 - 1]);
            mov(ecx, ptr[r9d + r13d * 4 - 1000]);
            mov(ecx, ptr[r9d + r13d * 8 + 0]);
            mov(ecx, ptr[r9d + r13d * 8 + 1]);
            mov(ecx, ptr[r9d + r13d * 8 + 1000]);
            mov(ecx, ptr[r9d + r13d * 8 - 1]);
            mov(ecx, ptr[r9d + r13d * 8 - 1000]);
        }
    }

    class gen31 : CodeGenerator {
        this()
        {
            mov(ecx, ptr[r9d + r14d + 0]);
            mov(ecx, ptr[r9d + r14d + 1]);
            mov(ecx, ptr[r9d + r14d + 1000]);
            mov(ecx, ptr[r9d + r14d - 1]);
            mov(ecx, ptr[r9d + r14d - 1000]);
            mov(ecx, ptr[r9d + r14d * 1 + 0]);
            mov(ecx, ptr[r9d + r14d * 1 + 1]);
            mov(ecx, ptr[r9d + r14d * 1 + 1000]);
            mov(ecx, ptr[r9d + r14d * 1 - 1]);
            mov(ecx, ptr[r9d + r14d * 1 - 1000]);
            mov(ecx, ptr[r9d + r14d * 2 + 0]);
            mov(ecx, ptr[r9d + r14d * 2 + 1]);
            mov(ecx, ptr[r9d + r14d * 2 + 1000]);
            mov(ecx, ptr[r9d + r14d * 2 - 1]);
            mov(ecx, ptr[r9d + r14d * 2 - 1000]);
            mov(ecx, ptr[r9d + r14d * 4 + 0]);
            mov(ecx, ptr[r9d + r14d * 4 + 1]);
            mov(ecx, ptr[r9d + r14d * 4 + 1000]);
            mov(ecx, ptr[r9d + r14d * 4 - 1]);
            mov(ecx, ptr[r9d + r14d * 4 - 1000]);
            mov(ecx, ptr[r9d + r14d * 8 + 0]);
            mov(ecx, ptr[r9d + r14d * 8 + 1]);
            mov(ecx, ptr[r9d + r14d * 8 + 1000]);
            mov(ecx, ptr[r9d + r14d * 8 - 1]);
            mov(ecx, ptr[r9d + r14d * 8 - 1000]);
            mov(ecx, ptr[r9d + r15d + 0]);
            mov(ecx, ptr[r9d + r15d + 1]);
            mov(ecx, ptr[r9d + r15d + 1000]);
            mov(ecx, ptr[r9d + r15d - 1]);
            mov(ecx, ptr[r9d + r15d - 1000]);
            mov(ecx, ptr[r9d + r15d * 1 + 0]);
            mov(ecx, ptr[r9d + r15d * 1 + 1]);
            mov(ecx, ptr[r9d + r15d * 1 + 1000]);
            mov(ecx, ptr[r9d + r15d * 1 - 1]);
            mov(ecx, ptr[r9d + r15d * 1 - 1000]);
            mov(ecx, ptr[r9d + r15d * 2 + 0]);
            mov(ecx, ptr[r9d + r15d * 2 + 1]);
            mov(ecx, ptr[r9d + r15d * 2 + 1000]);
            mov(ecx, ptr[r9d + r15d * 2 - 1]);
            mov(ecx, ptr[r9d + r15d * 2 - 1000]);
            mov(ecx, ptr[r9d + r15d * 4 + 0]);
            mov(ecx, ptr[r9d + r15d * 4 + 1]);
            mov(ecx, ptr[r9d + r15d * 4 + 1000]);
            mov(ecx, ptr[r9d + r15d * 4 - 1]);
            mov(ecx, ptr[r9d + r15d * 4 - 1000]);
            mov(ecx, ptr[r9d + r15d * 8 + 0]);
            mov(ecx, ptr[r9d + r15d * 8 + 1]);
            mov(ecx, ptr[r9d + r15d * 8 + 1000]);
            mov(ecx, ptr[r9d + r15d * 8 - 1]);
            mov(ecx, ptr[r9d + r15d * 8 - 1000]);
            mov(ecx, ptr[r10d + eax + 0]);
            mov(ecx, ptr[r10d + eax + 1]);
            mov(ecx, ptr[r10d + eax + 1000]);
            mov(ecx, ptr[r10d + eax - 1]);
            mov(ecx, ptr[r10d + eax - 1000]);
            mov(ecx, ptr[r10d + eax * 1 + 0]);
            mov(ecx, ptr[r10d + eax * 1 + 1]);
            mov(ecx, ptr[r10d + eax * 1 + 1000]);
            mov(ecx, ptr[r10d + eax * 1 - 1]);
            mov(ecx, ptr[r10d + eax * 1 - 1000]);
            mov(ecx, ptr[r10d + eax * 2 + 0]);
            mov(ecx, ptr[r10d + eax * 2 + 1]);
            mov(ecx, ptr[r10d + eax * 2 + 1000]);
            mov(ecx, ptr[r10d + eax * 2 - 1]);
            mov(ecx, ptr[r10d + eax * 2 - 1000]);
            mov(ecx, ptr[r10d + eax * 4 + 0]);
            mov(ecx, ptr[r10d + eax * 4 + 1]);
            mov(ecx, ptr[r10d + eax * 4 + 1000]);
            mov(ecx, ptr[r10d + eax * 4 - 1]);
            mov(ecx, ptr[r10d + eax * 4 - 1000]);
            mov(ecx, ptr[r10d + eax * 8 + 0]);
            mov(ecx, ptr[r10d + eax * 8 + 1]);
            mov(ecx, ptr[r10d + eax * 8 + 1000]);
            mov(ecx, ptr[r10d + eax * 8 - 1]);
            mov(ecx, ptr[r10d + eax * 8 - 1000]);
            mov(ecx, ptr[r10d + ecx + 0]);
            mov(ecx, ptr[r10d + ecx + 1]);
            mov(ecx, ptr[r10d + ecx + 1000]);
            mov(ecx, ptr[r10d + ecx - 1]);
            mov(ecx, ptr[r10d + ecx - 1000]);
            mov(ecx, ptr[r10d + ecx * 1 + 0]);
            mov(ecx, ptr[r10d + ecx * 1 + 1]);
            mov(ecx, ptr[r10d + ecx * 1 + 1000]);
            mov(ecx, ptr[r10d + ecx * 1 - 1]);
            mov(ecx, ptr[r10d + ecx * 1 - 1000]);
            mov(ecx, ptr[r10d + ecx * 2 + 0]);
            mov(ecx, ptr[r10d + ecx * 2 + 1]);
            mov(ecx, ptr[r10d + ecx * 2 + 1000]);
            mov(ecx, ptr[r10d + ecx * 2 - 1]);
            mov(ecx, ptr[r10d + ecx * 2 - 1000]);
            mov(ecx, ptr[r10d + ecx * 4 + 0]);
            mov(ecx, ptr[r10d + ecx * 4 + 1]);
            mov(ecx, ptr[r10d + ecx * 4 + 1000]);
            mov(ecx, ptr[r10d + ecx * 4 - 1]);
            mov(ecx, ptr[r10d + ecx * 4 - 1000]);
            mov(ecx, ptr[r10d + ecx * 8 + 0]);
            mov(ecx, ptr[r10d + ecx * 8 + 1]);
            mov(ecx, ptr[r10d + ecx * 8 + 1000]);
            mov(ecx, ptr[r10d + ecx * 8 - 1]);
            mov(ecx, ptr[r10d + ecx * 8 - 1000]);
        }
    }

    class gen32 : CodeGenerator {
        this()
        {
            mov(ecx, ptr[r10d + edx + 0]);
            mov(ecx, ptr[r10d + edx + 1]);
            mov(ecx, ptr[r10d + edx + 1000]);
            mov(ecx, ptr[r10d + edx - 1]);
            mov(ecx, ptr[r10d + edx - 1000]);
            mov(ecx, ptr[r10d + edx * 1 + 0]);
            mov(ecx, ptr[r10d + edx * 1 + 1]);
            mov(ecx, ptr[r10d + edx * 1 + 1000]);
            mov(ecx, ptr[r10d + edx * 1 - 1]);
            mov(ecx, ptr[r10d + edx * 1 - 1000]);
            mov(ecx, ptr[r10d + edx * 2 + 0]);
            mov(ecx, ptr[r10d + edx * 2 + 1]);
            mov(ecx, ptr[r10d + edx * 2 + 1000]);
            mov(ecx, ptr[r10d + edx * 2 - 1]);
            mov(ecx, ptr[r10d + edx * 2 - 1000]);
            mov(ecx, ptr[r10d + edx * 4 + 0]);
            mov(ecx, ptr[r10d + edx * 4 + 1]);
            mov(ecx, ptr[r10d + edx * 4 + 1000]);
            mov(ecx, ptr[r10d + edx * 4 - 1]);
            mov(ecx, ptr[r10d + edx * 4 - 1000]);
            mov(ecx, ptr[r10d + edx * 8 + 0]);
            mov(ecx, ptr[r10d + edx * 8 + 1]);
            mov(ecx, ptr[r10d + edx * 8 + 1000]);
            mov(ecx, ptr[r10d + edx * 8 - 1]);
            mov(ecx, ptr[r10d + edx * 8 - 1000]);
            mov(ecx, ptr[r10d + ebx + 0]);
            mov(ecx, ptr[r10d + ebx + 1]);
            mov(ecx, ptr[r10d + ebx + 1000]);
            mov(ecx, ptr[r10d + ebx - 1]);
            mov(ecx, ptr[r10d + ebx - 1000]);
            mov(ecx, ptr[r10d + ebx * 1 + 0]);
            mov(ecx, ptr[r10d + ebx * 1 + 1]);
            mov(ecx, ptr[r10d + ebx * 1 + 1000]);
            mov(ecx, ptr[r10d + ebx * 1 - 1]);
            mov(ecx, ptr[r10d + ebx * 1 - 1000]);
            mov(ecx, ptr[r10d + ebx * 2 + 0]);
            mov(ecx, ptr[r10d + ebx * 2 + 1]);
            mov(ecx, ptr[r10d + ebx * 2 + 1000]);
            mov(ecx, ptr[r10d + ebx * 2 - 1]);
            mov(ecx, ptr[r10d + ebx * 2 - 1000]);
            mov(ecx, ptr[r10d + ebx * 4 + 0]);
            mov(ecx, ptr[r10d + ebx * 4 + 1]);
            mov(ecx, ptr[r10d + ebx * 4 + 1000]);
            mov(ecx, ptr[r10d + ebx * 4 - 1]);
            mov(ecx, ptr[r10d + ebx * 4 - 1000]);
            mov(ecx, ptr[r10d + ebx * 8 + 0]);
            mov(ecx, ptr[r10d + ebx * 8 + 1]);
            mov(ecx, ptr[r10d + ebx * 8 + 1000]);
            mov(ecx, ptr[r10d + ebx * 8 - 1]);
            mov(ecx, ptr[r10d + ebx * 8 - 1000]);
            mov(ecx, ptr[r10d + ebp + 0]);
            mov(ecx, ptr[r10d + ebp + 1]);
            mov(ecx, ptr[r10d + ebp + 1000]);
            mov(ecx, ptr[r10d + ebp - 1]);
            mov(ecx, ptr[r10d + ebp - 1000]);
            mov(ecx, ptr[r10d + ebp * 1 + 0]);
            mov(ecx, ptr[r10d + ebp * 1 + 1]);
            mov(ecx, ptr[r10d + ebp * 1 + 1000]);
            mov(ecx, ptr[r10d + ebp * 1 - 1]);
            mov(ecx, ptr[r10d + ebp * 1 - 1000]);
            mov(ecx, ptr[r10d + ebp * 2 + 0]);
            mov(ecx, ptr[r10d + ebp * 2 + 1]);
            mov(ecx, ptr[r10d + ebp * 2 + 1000]);
            mov(ecx, ptr[r10d + ebp * 2 - 1]);
            mov(ecx, ptr[r10d + ebp * 2 - 1000]);
            mov(ecx, ptr[r10d + ebp * 4 + 0]);
            mov(ecx, ptr[r10d + ebp * 4 + 1]);
            mov(ecx, ptr[r10d + ebp * 4 + 1000]);
            mov(ecx, ptr[r10d + ebp * 4 - 1]);
            mov(ecx, ptr[r10d + ebp * 4 - 1000]);
            mov(ecx, ptr[r10d + ebp * 8 + 0]);
            mov(ecx, ptr[r10d + ebp * 8 + 1]);
            mov(ecx, ptr[r10d + ebp * 8 + 1000]);
            mov(ecx, ptr[r10d + ebp * 8 - 1]);
            mov(ecx, ptr[r10d + ebp * 8 - 1000]);
            mov(ecx, ptr[r10d + esi + 0]);
            mov(ecx, ptr[r10d + esi + 1]);
            mov(ecx, ptr[r10d + esi + 1000]);
            mov(ecx, ptr[r10d + esi - 1]);
            mov(ecx, ptr[r10d + esi - 1000]);
            mov(ecx, ptr[r10d + esi * 1 + 0]);
            mov(ecx, ptr[r10d + esi * 1 + 1]);
            mov(ecx, ptr[r10d + esi * 1 + 1000]);
            mov(ecx, ptr[r10d + esi * 1 - 1]);
            mov(ecx, ptr[r10d + esi * 1 - 1000]);
            mov(ecx, ptr[r10d + esi * 2 + 0]);
            mov(ecx, ptr[r10d + esi * 2 + 1]);
            mov(ecx, ptr[r10d + esi * 2 + 1000]);
            mov(ecx, ptr[r10d + esi * 2 - 1]);
            mov(ecx, ptr[r10d + esi * 2 - 1000]);
            mov(ecx, ptr[r10d + esi * 4 + 0]);
            mov(ecx, ptr[r10d + esi * 4 + 1]);
            mov(ecx, ptr[r10d + esi * 4 + 1000]);
            mov(ecx, ptr[r10d + esi * 4 - 1]);
            mov(ecx, ptr[r10d + esi * 4 - 1000]);
            mov(ecx, ptr[r10d + esi * 8 + 0]);
            mov(ecx, ptr[r10d + esi * 8 + 1]);
            mov(ecx, ptr[r10d + esi * 8 + 1000]);
            mov(ecx, ptr[r10d + esi * 8 - 1]);
            mov(ecx, ptr[r10d + esi * 8 - 1000]);
        }
    }

    class gen33 : CodeGenerator {
        this()
        {
            mov(ecx, ptr[r10d + edi + 0]);
            mov(ecx, ptr[r10d + edi + 1]);
            mov(ecx, ptr[r10d + edi + 1000]);
            mov(ecx, ptr[r10d + edi - 1]);
            mov(ecx, ptr[r10d + edi - 1000]);
            mov(ecx, ptr[r10d + edi * 1 + 0]);
            mov(ecx, ptr[r10d + edi * 1 + 1]);
            mov(ecx, ptr[r10d + edi * 1 + 1000]);
            mov(ecx, ptr[r10d + edi * 1 - 1]);
            mov(ecx, ptr[r10d + edi * 1 - 1000]);
            mov(ecx, ptr[r10d + edi * 2 + 0]);
            mov(ecx, ptr[r10d + edi * 2 + 1]);
            mov(ecx, ptr[r10d + edi * 2 + 1000]);
            mov(ecx, ptr[r10d + edi * 2 - 1]);
            mov(ecx, ptr[r10d + edi * 2 - 1000]);
            mov(ecx, ptr[r10d + edi * 4 + 0]);
            mov(ecx, ptr[r10d + edi * 4 + 1]);
            mov(ecx, ptr[r10d + edi * 4 + 1000]);
            mov(ecx, ptr[r10d + edi * 4 - 1]);
            mov(ecx, ptr[r10d + edi * 4 - 1000]);
            mov(ecx, ptr[r10d + edi * 8 + 0]);
            mov(ecx, ptr[r10d + edi * 8 + 1]);
            mov(ecx, ptr[r10d + edi * 8 + 1000]);
            mov(ecx, ptr[r10d + edi * 8 - 1]);
            mov(ecx, ptr[r10d + edi * 8 - 1000]);
            mov(ecx, ptr[r10d + r9d + 0]);
            mov(ecx, ptr[r10d + r9d + 1]);
            mov(ecx, ptr[r10d + r9d + 1000]);
            mov(ecx, ptr[r10d + r9d - 1]);
            mov(ecx, ptr[r10d + r9d - 1000]);
            mov(ecx, ptr[r10d + r9d * 1 + 0]);
            mov(ecx, ptr[r10d + r9d * 1 + 1]);
            mov(ecx, ptr[r10d + r9d * 1 + 1000]);
            mov(ecx, ptr[r10d + r9d * 1 - 1]);
            mov(ecx, ptr[r10d + r9d * 1 - 1000]);
            mov(ecx, ptr[r10d + r9d * 2 + 0]);
            mov(ecx, ptr[r10d + r9d * 2 + 1]);
            mov(ecx, ptr[r10d + r9d * 2 + 1000]);
            mov(ecx, ptr[r10d + r9d * 2 - 1]);
            mov(ecx, ptr[r10d + r9d * 2 - 1000]);
            mov(ecx, ptr[r10d + r9d * 4 + 0]);
            mov(ecx, ptr[r10d + r9d * 4 + 1]);
            mov(ecx, ptr[r10d + r9d * 4 + 1000]);
            mov(ecx, ptr[r10d + r9d * 4 - 1]);
            mov(ecx, ptr[r10d + r9d * 4 - 1000]);
            mov(ecx, ptr[r10d + r9d * 8 + 0]);
            mov(ecx, ptr[r10d + r9d * 8 + 1]);
            mov(ecx, ptr[r10d + r9d * 8 + 1000]);
            mov(ecx, ptr[r10d + r9d * 8 - 1]);
            mov(ecx, ptr[r10d + r9d * 8 - 1000]);
            mov(ecx, ptr[r10d + r10d + 0]);
            mov(ecx, ptr[r10d + r10d + 1]);
            mov(ecx, ptr[r10d + r10d + 1000]);
            mov(ecx, ptr[r10d + r10d - 1]);
            mov(ecx, ptr[r10d + r10d - 1000]);
            mov(ecx, ptr[r10d + r10d * 1 + 0]);
            mov(ecx, ptr[r10d + r10d * 1 + 1]);
            mov(ecx, ptr[r10d + r10d * 1 + 1000]);
            mov(ecx, ptr[r10d + r10d * 1 - 1]);
            mov(ecx, ptr[r10d + r10d * 1 - 1000]);
            mov(ecx, ptr[r10d + r10d * 2 + 0]);
            mov(ecx, ptr[r10d + r10d * 2 + 1]);
            mov(ecx, ptr[r10d + r10d * 2 + 1000]);
            mov(ecx, ptr[r10d + r10d * 2 - 1]);
            mov(ecx, ptr[r10d + r10d * 2 - 1000]);
            mov(ecx, ptr[r10d + r10d * 4 + 0]);
            mov(ecx, ptr[r10d + r10d * 4 + 1]);
            mov(ecx, ptr[r10d + r10d * 4 + 1000]);
            mov(ecx, ptr[r10d + r10d * 4 - 1]);
            mov(ecx, ptr[r10d + r10d * 4 - 1000]);
            mov(ecx, ptr[r10d + r10d * 8 + 0]);
            mov(ecx, ptr[r10d + r10d * 8 + 1]);
            mov(ecx, ptr[r10d + r10d * 8 + 1000]);
            mov(ecx, ptr[r10d + r10d * 8 - 1]);
            mov(ecx, ptr[r10d + r10d * 8 - 1000]);
            mov(ecx, ptr[r10d + r11d + 0]);
            mov(ecx, ptr[r10d + r11d + 1]);
            mov(ecx, ptr[r10d + r11d + 1000]);
            mov(ecx, ptr[r10d + r11d - 1]);
            mov(ecx, ptr[r10d + r11d - 1000]);
            mov(ecx, ptr[r10d + r11d * 1 + 0]);
            mov(ecx, ptr[r10d + r11d * 1 + 1]);
            mov(ecx, ptr[r10d + r11d * 1 + 1000]);
            mov(ecx, ptr[r10d + r11d * 1 - 1]);
            mov(ecx, ptr[r10d + r11d * 1 - 1000]);
            mov(ecx, ptr[r10d + r11d * 2 + 0]);
            mov(ecx, ptr[r10d + r11d * 2 + 1]);
            mov(ecx, ptr[r10d + r11d * 2 + 1000]);
            mov(ecx, ptr[r10d + r11d * 2 - 1]);
            mov(ecx, ptr[r10d + r11d * 2 - 1000]);
            mov(ecx, ptr[r10d + r11d * 4 + 0]);
            mov(ecx, ptr[r10d + r11d * 4 + 1]);
            mov(ecx, ptr[r10d + r11d * 4 + 1000]);
            mov(ecx, ptr[r10d + r11d * 4 - 1]);
            mov(ecx, ptr[r10d + r11d * 4 - 1000]);
            mov(ecx, ptr[r10d + r11d * 8 + 0]);
            mov(ecx, ptr[r10d + r11d * 8 + 1]);
            mov(ecx, ptr[r10d + r11d * 8 + 1000]);
            mov(ecx, ptr[r10d + r11d * 8 - 1]);
            mov(ecx, ptr[r10d + r11d * 8 - 1000]);
        }
    }

    class gen34 : CodeGenerator {
        this()
        {
            mov(ecx, ptr[r10d + r12d + 0]);
            mov(ecx, ptr[r10d + r12d + 1]);
            mov(ecx, ptr[r10d + r12d + 1000]);
            mov(ecx, ptr[r10d + r12d - 1]);
            mov(ecx, ptr[r10d + r12d - 1000]);
            mov(ecx, ptr[r10d + r12d * 1 + 0]);
            mov(ecx, ptr[r10d + r12d * 1 + 1]);
            mov(ecx, ptr[r10d + r12d * 1 + 1000]);
            mov(ecx, ptr[r10d + r12d * 1 - 1]);
            mov(ecx, ptr[r10d + r12d * 1 - 1000]);
            mov(ecx, ptr[r10d + r12d * 2 + 0]);
            mov(ecx, ptr[r10d + r12d * 2 + 1]);
            mov(ecx, ptr[r10d + r12d * 2 + 1000]);
            mov(ecx, ptr[r10d + r12d * 2 - 1]);
            mov(ecx, ptr[r10d + r12d * 2 - 1000]);
            mov(ecx, ptr[r10d + r12d * 4 + 0]);
            mov(ecx, ptr[r10d + r12d * 4 + 1]);
            mov(ecx, ptr[r10d + r12d * 4 + 1000]);
            mov(ecx, ptr[r10d + r12d * 4 - 1]);
            mov(ecx, ptr[r10d + r12d * 4 - 1000]);
            mov(ecx, ptr[r10d + r12d * 8 + 0]);
            mov(ecx, ptr[r10d + r12d * 8 + 1]);
            mov(ecx, ptr[r10d + r12d * 8 + 1000]);
            mov(ecx, ptr[r10d + r12d * 8 - 1]);
            mov(ecx, ptr[r10d + r12d * 8 - 1000]);
            mov(ecx, ptr[r10d + r13d + 0]);
            mov(ecx, ptr[r10d + r13d + 1]);
            mov(ecx, ptr[r10d + r13d + 1000]);
            mov(ecx, ptr[r10d + r13d - 1]);
            mov(ecx, ptr[r10d + r13d - 1000]);
            mov(ecx, ptr[r10d + r13d * 1 + 0]);
            mov(ecx, ptr[r10d + r13d * 1 + 1]);
            mov(ecx, ptr[r10d + r13d * 1 + 1000]);
            mov(ecx, ptr[r10d + r13d * 1 - 1]);
            mov(ecx, ptr[r10d + r13d * 1 - 1000]);
            mov(ecx, ptr[r10d + r13d * 2 + 0]);
            mov(ecx, ptr[r10d + r13d * 2 + 1]);
            mov(ecx, ptr[r10d + r13d * 2 + 1000]);
            mov(ecx, ptr[r10d + r13d * 2 - 1]);
            mov(ecx, ptr[r10d + r13d * 2 - 1000]);
            mov(ecx, ptr[r10d + r13d * 4 + 0]);
            mov(ecx, ptr[r10d + r13d * 4 + 1]);
            mov(ecx, ptr[r10d + r13d * 4 + 1000]);
            mov(ecx, ptr[r10d + r13d * 4 - 1]);
            mov(ecx, ptr[r10d + r13d * 4 - 1000]);
            mov(ecx, ptr[r10d + r13d * 8 + 0]);
            mov(ecx, ptr[r10d + r13d * 8 + 1]);
            mov(ecx, ptr[r10d + r13d * 8 + 1000]);
            mov(ecx, ptr[r10d + r13d * 8 - 1]);
            mov(ecx, ptr[r10d + r13d * 8 - 1000]);
            mov(ecx, ptr[r10d + r14d + 0]);
            mov(ecx, ptr[r10d + r14d + 1]);
            mov(ecx, ptr[r10d + r14d + 1000]);
            mov(ecx, ptr[r10d + r14d - 1]);
            mov(ecx, ptr[r10d + r14d - 1000]);
            mov(ecx, ptr[r10d + r14d * 1 + 0]);
            mov(ecx, ptr[r10d + r14d * 1 + 1]);
            mov(ecx, ptr[r10d + r14d * 1 + 1000]);
            mov(ecx, ptr[r10d + r14d * 1 - 1]);
            mov(ecx, ptr[r10d + r14d * 1 - 1000]);
            mov(ecx, ptr[r10d + r14d * 2 + 0]);
            mov(ecx, ptr[r10d + r14d * 2 + 1]);
            mov(ecx, ptr[r10d + r14d * 2 + 1000]);
            mov(ecx, ptr[r10d + r14d * 2 - 1]);
            mov(ecx, ptr[r10d + r14d * 2 - 1000]);
            mov(ecx, ptr[r10d + r14d * 4 + 0]);
            mov(ecx, ptr[r10d + r14d * 4 + 1]);
            mov(ecx, ptr[r10d + r14d * 4 + 1000]);
            mov(ecx, ptr[r10d + r14d * 4 - 1]);
            mov(ecx, ptr[r10d + r14d * 4 - 1000]);
            mov(ecx, ptr[r10d + r14d * 8 + 0]);
            mov(ecx, ptr[r10d + r14d * 8 + 1]);
            mov(ecx, ptr[r10d + r14d * 8 + 1000]);
            mov(ecx, ptr[r10d + r14d * 8 - 1]);
            mov(ecx, ptr[r10d + r14d * 8 - 1000]);
            mov(ecx, ptr[r10d + r15d + 0]);
            mov(ecx, ptr[r10d + r15d + 1]);
            mov(ecx, ptr[r10d + r15d + 1000]);
            mov(ecx, ptr[r10d + r15d - 1]);
            mov(ecx, ptr[r10d + r15d - 1000]);
            mov(ecx, ptr[r10d + r15d * 1 + 0]);
            mov(ecx, ptr[r10d + r15d * 1 + 1]);
            mov(ecx, ptr[r10d + r15d * 1 + 1000]);
            mov(ecx, ptr[r10d + r15d * 1 - 1]);
            mov(ecx, ptr[r10d + r15d * 1 - 1000]);
            mov(ecx, ptr[r10d + r15d * 2 + 0]);
            mov(ecx, ptr[r10d + r15d * 2 + 1]);
            mov(ecx, ptr[r10d + r15d * 2 + 1000]);
            mov(ecx, ptr[r10d + r15d * 2 - 1]);
            mov(ecx, ptr[r10d + r15d * 2 - 1000]);
            mov(ecx, ptr[r10d + r15d * 4 + 0]);
            mov(ecx, ptr[r10d + r15d * 4 + 1]);
            mov(ecx, ptr[r10d + r15d * 4 + 1000]);
            mov(ecx, ptr[r10d + r15d * 4 - 1]);
            mov(ecx, ptr[r10d + r15d * 4 - 1000]);
            mov(ecx, ptr[r10d + r15d * 8 + 0]);
            mov(ecx, ptr[r10d + r15d * 8 + 1]);
            mov(ecx, ptr[r10d + r15d * 8 + 1000]);
            mov(ecx, ptr[r10d + r15d * 8 - 1]);
            mov(ecx, ptr[r10d + r15d * 8 - 1000]);
        }
    }

    class gen35 : CodeGenerator {
        this()
        {
            mov(ecx, ptr[r11d + eax + 0]);
            mov(ecx, ptr[r11d + eax + 1]);
            mov(ecx, ptr[r11d + eax + 1000]);
            mov(ecx, ptr[r11d + eax - 1]);
            mov(ecx, ptr[r11d + eax - 1000]);
            mov(ecx, ptr[r11d + eax * 1 + 0]);
            mov(ecx, ptr[r11d + eax * 1 + 1]);
            mov(ecx, ptr[r11d + eax * 1 + 1000]);
            mov(ecx, ptr[r11d + eax * 1 - 1]);
            mov(ecx, ptr[r11d + eax * 1 - 1000]);
            mov(ecx, ptr[r11d + eax * 2 + 0]);
            mov(ecx, ptr[r11d + eax * 2 + 1]);
            mov(ecx, ptr[r11d + eax * 2 + 1000]);
            mov(ecx, ptr[r11d + eax * 2 - 1]);
            mov(ecx, ptr[r11d + eax * 2 - 1000]);
            mov(ecx, ptr[r11d + eax * 4 + 0]);
            mov(ecx, ptr[r11d + eax * 4 + 1]);
            mov(ecx, ptr[r11d + eax * 4 + 1000]);
            mov(ecx, ptr[r11d + eax * 4 - 1]);
            mov(ecx, ptr[r11d + eax * 4 - 1000]);
            mov(ecx, ptr[r11d + eax * 8 + 0]);
            mov(ecx, ptr[r11d + eax * 8 + 1]);
            mov(ecx, ptr[r11d + eax * 8 + 1000]);
            mov(ecx, ptr[r11d + eax * 8 - 1]);
            mov(ecx, ptr[r11d + eax * 8 - 1000]);
            mov(ecx, ptr[r11d + ecx + 0]);
            mov(ecx, ptr[r11d + ecx + 1]);
            mov(ecx, ptr[r11d + ecx + 1000]);
            mov(ecx, ptr[r11d + ecx - 1]);
            mov(ecx, ptr[r11d + ecx - 1000]);
            mov(ecx, ptr[r11d + ecx * 1 + 0]);
            mov(ecx, ptr[r11d + ecx * 1 + 1]);
            mov(ecx, ptr[r11d + ecx * 1 + 1000]);
            mov(ecx, ptr[r11d + ecx * 1 - 1]);
            mov(ecx, ptr[r11d + ecx * 1 - 1000]);
            mov(ecx, ptr[r11d + ecx * 2 + 0]);
            mov(ecx, ptr[r11d + ecx * 2 + 1]);
            mov(ecx, ptr[r11d + ecx * 2 + 1000]);
            mov(ecx, ptr[r11d + ecx * 2 - 1]);
            mov(ecx, ptr[r11d + ecx * 2 - 1000]);
            mov(ecx, ptr[r11d + ecx * 4 + 0]);
            mov(ecx, ptr[r11d + ecx * 4 + 1]);
            mov(ecx, ptr[r11d + ecx * 4 + 1000]);
            mov(ecx, ptr[r11d + ecx * 4 - 1]);
            mov(ecx, ptr[r11d + ecx * 4 - 1000]);
            mov(ecx, ptr[r11d + ecx * 8 + 0]);
            mov(ecx, ptr[r11d + ecx * 8 + 1]);
            mov(ecx, ptr[r11d + ecx * 8 + 1000]);
            mov(ecx, ptr[r11d + ecx * 8 - 1]);
            mov(ecx, ptr[r11d + ecx * 8 - 1000]);
            mov(ecx, ptr[r11d + edx + 0]);
            mov(ecx, ptr[r11d + edx + 1]);
            mov(ecx, ptr[r11d + edx + 1000]);
            mov(ecx, ptr[r11d + edx - 1]);
            mov(ecx, ptr[r11d + edx - 1000]);
            mov(ecx, ptr[r11d + edx * 1 + 0]);
            mov(ecx, ptr[r11d + edx * 1 + 1]);
            mov(ecx, ptr[r11d + edx * 1 + 1000]);
            mov(ecx, ptr[r11d + edx * 1 - 1]);
            mov(ecx, ptr[r11d + edx * 1 - 1000]);
            mov(ecx, ptr[r11d + edx * 2 + 0]);
            mov(ecx, ptr[r11d + edx * 2 + 1]);
            mov(ecx, ptr[r11d + edx * 2 + 1000]);
            mov(ecx, ptr[r11d + edx * 2 - 1]);
            mov(ecx, ptr[r11d + edx * 2 - 1000]);
            mov(ecx, ptr[r11d + edx * 4 + 0]);
            mov(ecx, ptr[r11d + edx * 4 + 1]);
            mov(ecx, ptr[r11d + edx * 4 + 1000]);
            mov(ecx, ptr[r11d + edx * 4 - 1]);
            mov(ecx, ptr[r11d + edx * 4 - 1000]);
            mov(ecx, ptr[r11d + edx * 8 + 0]);
            mov(ecx, ptr[r11d + edx * 8 + 1]);
            mov(ecx, ptr[r11d + edx * 8 + 1000]);
            mov(ecx, ptr[r11d + edx * 8 - 1]);
            mov(ecx, ptr[r11d + edx * 8 - 1000]);
            mov(ecx, ptr[r11d + ebx + 0]);
            mov(ecx, ptr[r11d + ebx + 1]);
            mov(ecx, ptr[r11d + ebx + 1000]);
            mov(ecx, ptr[r11d + ebx - 1]);
            mov(ecx, ptr[r11d + ebx - 1000]);
            mov(ecx, ptr[r11d + ebx * 1 + 0]);
            mov(ecx, ptr[r11d + ebx * 1 + 1]);
            mov(ecx, ptr[r11d + ebx * 1 + 1000]);
            mov(ecx, ptr[r11d + ebx * 1 - 1]);
            mov(ecx, ptr[r11d + ebx * 1 - 1000]);
            mov(ecx, ptr[r11d + ebx * 2 + 0]);
            mov(ecx, ptr[r11d + ebx * 2 + 1]);
            mov(ecx, ptr[r11d + ebx * 2 + 1000]);
            mov(ecx, ptr[r11d + ebx * 2 - 1]);
            mov(ecx, ptr[r11d + ebx * 2 - 1000]);
            mov(ecx, ptr[r11d + ebx * 4 + 0]);
            mov(ecx, ptr[r11d + ebx * 4 + 1]);
            mov(ecx, ptr[r11d + ebx * 4 + 1000]);
            mov(ecx, ptr[r11d + ebx * 4 - 1]);
            mov(ecx, ptr[r11d + ebx * 4 - 1000]);
            mov(ecx, ptr[r11d + ebx * 8 + 0]);
            mov(ecx, ptr[r11d + ebx * 8 + 1]);
            mov(ecx, ptr[r11d + ebx * 8 + 1000]);
            mov(ecx, ptr[r11d + ebx * 8 - 1]);
            mov(ecx, ptr[r11d + ebx * 8 - 1000]);
        }
    }

    class gen36 : CodeGenerator {
        this()
        {
            mov(ecx, ptr[r11d + ebp + 0]);
            mov(ecx, ptr[r11d + ebp + 1]);
            mov(ecx, ptr[r11d + ebp + 1000]);
            mov(ecx, ptr[r11d + ebp - 1]);
            mov(ecx, ptr[r11d + ebp - 1000]);
            mov(ecx, ptr[r11d + ebp * 1 + 0]);
            mov(ecx, ptr[r11d + ebp * 1 + 1]);
            mov(ecx, ptr[r11d + ebp * 1 + 1000]);
            mov(ecx, ptr[r11d + ebp * 1 - 1]);
            mov(ecx, ptr[r11d + ebp * 1 - 1000]);
            mov(ecx, ptr[r11d + ebp * 2 + 0]);
            mov(ecx, ptr[r11d + ebp * 2 + 1]);
            mov(ecx, ptr[r11d + ebp * 2 + 1000]);
            mov(ecx, ptr[r11d + ebp * 2 - 1]);
            mov(ecx, ptr[r11d + ebp * 2 - 1000]);
            mov(ecx, ptr[r11d + ebp * 4 + 0]);
            mov(ecx, ptr[r11d + ebp * 4 + 1]);
            mov(ecx, ptr[r11d + ebp * 4 + 1000]);
            mov(ecx, ptr[r11d + ebp * 4 - 1]);
            mov(ecx, ptr[r11d + ebp * 4 - 1000]);
            mov(ecx, ptr[r11d + ebp * 8 + 0]);
            mov(ecx, ptr[r11d + ebp * 8 + 1]);
            mov(ecx, ptr[r11d + ebp * 8 + 1000]);
            mov(ecx, ptr[r11d + ebp * 8 - 1]);
            mov(ecx, ptr[r11d + ebp * 8 - 1000]);
            mov(ecx, ptr[r11d + esi + 0]);
            mov(ecx, ptr[r11d + esi + 1]);
            mov(ecx, ptr[r11d + esi + 1000]);
            mov(ecx, ptr[r11d + esi - 1]);
            mov(ecx, ptr[r11d + esi - 1000]);
            mov(ecx, ptr[r11d + esi * 1 + 0]);
            mov(ecx, ptr[r11d + esi * 1 + 1]);
            mov(ecx, ptr[r11d + esi * 1 + 1000]);
            mov(ecx, ptr[r11d + esi * 1 - 1]);
            mov(ecx, ptr[r11d + esi * 1 - 1000]);
            mov(ecx, ptr[r11d + esi * 2 + 0]);
            mov(ecx, ptr[r11d + esi * 2 + 1]);
            mov(ecx, ptr[r11d + esi * 2 + 1000]);
            mov(ecx, ptr[r11d + esi * 2 - 1]);
            mov(ecx, ptr[r11d + esi * 2 - 1000]);
            mov(ecx, ptr[r11d + esi * 4 + 0]);
            mov(ecx, ptr[r11d + esi * 4 + 1]);
            mov(ecx, ptr[r11d + esi * 4 + 1000]);
            mov(ecx, ptr[r11d + esi * 4 - 1]);
            mov(ecx, ptr[r11d + esi * 4 - 1000]);
            mov(ecx, ptr[r11d + esi * 8 + 0]);
            mov(ecx, ptr[r11d + esi * 8 + 1]);
            mov(ecx, ptr[r11d + esi * 8 + 1000]);
            mov(ecx, ptr[r11d + esi * 8 - 1]);
            mov(ecx, ptr[r11d + esi * 8 - 1000]);
            mov(ecx, ptr[r11d + edi + 0]);
            mov(ecx, ptr[r11d + edi + 1]);
            mov(ecx, ptr[r11d + edi + 1000]);
            mov(ecx, ptr[r11d + edi - 1]);
            mov(ecx, ptr[r11d + edi - 1000]);
            mov(ecx, ptr[r11d + edi * 1 + 0]);
            mov(ecx, ptr[r11d + edi * 1 + 1]);
            mov(ecx, ptr[r11d + edi * 1 + 1000]);
            mov(ecx, ptr[r11d + edi * 1 - 1]);
            mov(ecx, ptr[r11d + edi * 1 - 1000]);
            mov(ecx, ptr[r11d + edi * 2 + 0]);
            mov(ecx, ptr[r11d + edi * 2 + 1]);
            mov(ecx, ptr[r11d + edi * 2 + 1000]);
            mov(ecx, ptr[r11d + edi * 2 - 1]);
            mov(ecx, ptr[r11d + edi * 2 - 1000]);
            mov(ecx, ptr[r11d + edi * 4 + 0]);
            mov(ecx, ptr[r11d + edi * 4 + 1]);
            mov(ecx, ptr[r11d + edi * 4 + 1000]);
            mov(ecx, ptr[r11d + edi * 4 - 1]);
            mov(ecx, ptr[r11d + edi * 4 - 1000]);
            mov(ecx, ptr[r11d + edi * 8 + 0]);
            mov(ecx, ptr[r11d + edi * 8 + 1]);
            mov(ecx, ptr[r11d + edi * 8 + 1000]);
            mov(ecx, ptr[r11d + edi * 8 - 1]);
            mov(ecx, ptr[r11d + edi * 8 - 1000]);
            mov(ecx, ptr[r11d + r9d + 0]);
            mov(ecx, ptr[r11d + r9d + 1]);
            mov(ecx, ptr[r11d + r9d + 1000]);
            mov(ecx, ptr[r11d + r9d - 1]);
            mov(ecx, ptr[r11d + r9d - 1000]);
            mov(ecx, ptr[r11d + r9d * 1 + 0]);
            mov(ecx, ptr[r11d + r9d * 1 + 1]);
            mov(ecx, ptr[r11d + r9d * 1 + 1000]);
            mov(ecx, ptr[r11d + r9d * 1 - 1]);
            mov(ecx, ptr[r11d + r9d * 1 - 1000]);
            mov(ecx, ptr[r11d + r9d * 2 + 0]);
            mov(ecx, ptr[r11d + r9d * 2 + 1]);
            mov(ecx, ptr[r11d + r9d * 2 + 1000]);
            mov(ecx, ptr[r11d + r9d * 2 - 1]);
            mov(ecx, ptr[r11d + r9d * 2 - 1000]);
            mov(ecx, ptr[r11d + r9d * 4 + 0]);
            mov(ecx, ptr[r11d + r9d * 4 + 1]);
            mov(ecx, ptr[r11d + r9d * 4 + 1000]);
            mov(ecx, ptr[r11d + r9d * 4 - 1]);
            mov(ecx, ptr[r11d + r9d * 4 - 1000]);
            mov(ecx, ptr[r11d + r9d * 8 + 0]);
            mov(ecx, ptr[r11d + r9d * 8 + 1]);
            mov(ecx, ptr[r11d + r9d * 8 + 1000]);
            mov(ecx, ptr[r11d + r9d * 8 - 1]);
            mov(ecx, ptr[r11d + r9d * 8 - 1000]);
        }
    }

    class gen37 : CodeGenerator {
        this()
        {
            mov(ecx, ptr[r11d + r10d + 0]);
            mov(ecx, ptr[r11d + r10d + 1]);
            mov(ecx, ptr[r11d + r10d + 1000]);
            mov(ecx, ptr[r11d + r10d - 1]);
            mov(ecx, ptr[r11d + r10d - 1000]);
            mov(ecx, ptr[r11d + r10d * 1 + 0]);
            mov(ecx, ptr[r11d + r10d * 1 + 1]);
            mov(ecx, ptr[r11d + r10d * 1 + 1000]);
            mov(ecx, ptr[r11d + r10d * 1 - 1]);
            mov(ecx, ptr[r11d + r10d * 1 - 1000]);
            mov(ecx, ptr[r11d + r10d * 2 + 0]);
            mov(ecx, ptr[r11d + r10d * 2 + 1]);
            mov(ecx, ptr[r11d + r10d * 2 + 1000]);
            mov(ecx, ptr[r11d + r10d * 2 - 1]);
            mov(ecx, ptr[r11d + r10d * 2 - 1000]);
            mov(ecx, ptr[r11d + r10d * 4 + 0]);
            mov(ecx, ptr[r11d + r10d * 4 + 1]);
            mov(ecx, ptr[r11d + r10d * 4 + 1000]);
            mov(ecx, ptr[r11d + r10d * 4 - 1]);
            mov(ecx, ptr[r11d + r10d * 4 - 1000]);
            mov(ecx, ptr[r11d + r10d * 8 + 0]);
            mov(ecx, ptr[r11d + r10d * 8 + 1]);
            mov(ecx, ptr[r11d + r10d * 8 + 1000]);
            mov(ecx, ptr[r11d + r10d * 8 - 1]);
            mov(ecx, ptr[r11d + r10d * 8 - 1000]);
            mov(ecx, ptr[r11d + r11d + 0]);
            mov(ecx, ptr[r11d + r11d + 1]);
            mov(ecx, ptr[r11d + r11d + 1000]);
            mov(ecx, ptr[r11d + r11d - 1]);
            mov(ecx, ptr[r11d + r11d - 1000]);
            mov(ecx, ptr[r11d + r11d * 1 + 0]);
            mov(ecx, ptr[r11d + r11d * 1 + 1]);
            mov(ecx, ptr[r11d + r11d * 1 + 1000]);
            mov(ecx, ptr[r11d + r11d * 1 - 1]);
            mov(ecx, ptr[r11d + r11d * 1 - 1000]);
            mov(ecx, ptr[r11d + r11d * 2 + 0]);
            mov(ecx, ptr[r11d + r11d * 2 + 1]);
            mov(ecx, ptr[r11d + r11d * 2 + 1000]);
            mov(ecx, ptr[r11d + r11d * 2 - 1]);
            mov(ecx, ptr[r11d + r11d * 2 - 1000]);
            mov(ecx, ptr[r11d + r11d * 4 + 0]);
            mov(ecx, ptr[r11d + r11d * 4 + 1]);
            mov(ecx, ptr[r11d + r11d * 4 + 1000]);
            mov(ecx, ptr[r11d + r11d * 4 - 1]);
            mov(ecx, ptr[r11d + r11d * 4 - 1000]);
            mov(ecx, ptr[r11d + r11d * 8 + 0]);
            mov(ecx, ptr[r11d + r11d * 8 + 1]);
            mov(ecx, ptr[r11d + r11d * 8 + 1000]);
            mov(ecx, ptr[r11d + r11d * 8 - 1]);
            mov(ecx, ptr[r11d + r11d * 8 - 1000]);
            mov(ecx, ptr[r11d + r12d + 0]);
            mov(ecx, ptr[r11d + r12d + 1]);
            mov(ecx, ptr[r11d + r12d + 1000]);
            mov(ecx, ptr[r11d + r12d - 1]);
            mov(ecx, ptr[r11d + r12d - 1000]);
            mov(ecx, ptr[r11d + r12d * 1 + 0]);
            mov(ecx, ptr[r11d + r12d * 1 + 1]);
            mov(ecx, ptr[r11d + r12d * 1 + 1000]);
            mov(ecx, ptr[r11d + r12d * 1 - 1]);
            mov(ecx, ptr[r11d + r12d * 1 - 1000]);
            mov(ecx, ptr[r11d + r12d * 2 + 0]);
            mov(ecx, ptr[r11d + r12d * 2 + 1]);
            mov(ecx, ptr[r11d + r12d * 2 + 1000]);
            mov(ecx, ptr[r11d + r12d * 2 - 1]);
            mov(ecx, ptr[r11d + r12d * 2 - 1000]);
            mov(ecx, ptr[r11d + r12d * 4 + 0]);
            mov(ecx, ptr[r11d + r12d * 4 + 1]);
            mov(ecx, ptr[r11d + r12d * 4 + 1000]);
            mov(ecx, ptr[r11d + r12d * 4 - 1]);
            mov(ecx, ptr[r11d + r12d * 4 - 1000]);
            mov(ecx, ptr[r11d + r12d * 8 + 0]);
            mov(ecx, ptr[r11d + r12d * 8 + 1]);
            mov(ecx, ptr[r11d + r12d * 8 + 1000]);
            mov(ecx, ptr[r11d + r12d * 8 - 1]);
            mov(ecx, ptr[r11d + r12d * 8 - 1000]);
            mov(ecx, ptr[r11d + r13d + 0]);
            mov(ecx, ptr[r11d + r13d + 1]);
            mov(ecx, ptr[r11d + r13d + 1000]);
            mov(ecx, ptr[r11d + r13d - 1]);
            mov(ecx, ptr[r11d + r13d - 1000]);
            mov(ecx, ptr[r11d + r13d * 1 + 0]);
            mov(ecx, ptr[r11d + r13d * 1 + 1]);
            mov(ecx, ptr[r11d + r13d * 1 + 1000]);
            mov(ecx, ptr[r11d + r13d * 1 - 1]);
            mov(ecx, ptr[r11d + r13d * 1 - 1000]);
            mov(ecx, ptr[r11d + r13d * 2 + 0]);
            mov(ecx, ptr[r11d + r13d * 2 + 1]);
            mov(ecx, ptr[r11d + r13d * 2 + 1000]);
            mov(ecx, ptr[r11d + r13d * 2 - 1]);
            mov(ecx, ptr[r11d + r13d * 2 - 1000]);
            mov(ecx, ptr[r11d + r13d * 4 + 0]);
            mov(ecx, ptr[r11d + r13d * 4 + 1]);
            mov(ecx, ptr[r11d + r13d * 4 + 1000]);
            mov(ecx, ptr[r11d + r13d * 4 - 1]);
            mov(ecx, ptr[r11d + r13d * 4 - 1000]);
            mov(ecx, ptr[r11d + r13d * 8 + 0]);
            mov(ecx, ptr[r11d + r13d * 8 + 1]);
            mov(ecx, ptr[r11d + r13d * 8 + 1000]);
            mov(ecx, ptr[r11d + r13d * 8 - 1]);
            mov(ecx, ptr[r11d + r13d * 8 - 1000]);
        }
    }

    class gen38 : CodeGenerator {
        this()
        {
            mov(ecx, ptr[r11d + r14d + 0]);
            mov(ecx, ptr[r11d + r14d + 1]);
            mov(ecx, ptr[r11d + r14d + 1000]);
            mov(ecx, ptr[r11d + r14d - 1]);
            mov(ecx, ptr[r11d + r14d - 1000]);
            mov(ecx, ptr[r11d + r14d * 1 + 0]);
            mov(ecx, ptr[r11d + r14d * 1 + 1]);
            mov(ecx, ptr[r11d + r14d * 1 + 1000]);
            mov(ecx, ptr[r11d + r14d * 1 - 1]);
            mov(ecx, ptr[r11d + r14d * 1 - 1000]);
            mov(ecx, ptr[r11d + r14d * 2 + 0]);
            mov(ecx, ptr[r11d + r14d * 2 + 1]);
            mov(ecx, ptr[r11d + r14d * 2 + 1000]);
            mov(ecx, ptr[r11d + r14d * 2 - 1]);
            mov(ecx, ptr[r11d + r14d * 2 - 1000]);
            mov(ecx, ptr[r11d + r14d * 4 + 0]);
            mov(ecx, ptr[r11d + r14d * 4 + 1]);
            mov(ecx, ptr[r11d + r14d * 4 + 1000]);
            mov(ecx, ptr[r11d + r14d * 4 - 1]);
            mov(ecx, ptr[r11d + r14d * 4 - 1000]);
            mov(ecx, ptr[r11d + r14d * 8 + 0]);
            mov(ecx, ptr[r11d + r14d * 8 + 1]);
            mov(ecx, ptr[r11d + r14d * 8 + 1000]);
            mov(ecx, ptr[r11d + r14d * 8 - 1]);
            mov(ecx, ptr[r11d + r14d * 8 - 1000]);
            mov(ecx, ptr[r11d + r15d + 0]);
            mov(ecx, ptr[r11d + r15d + 1]);
            mov(ecx, ptr[r11d + r15d + 1000]);
            mov(ecx, ptr[r11d + r15d - 1]);
            mov(ecx, ptr[r11d + r15d - 1000]);
            mov(ecx, ptr[r11d + r15d * 1 + 0]);
            mov(ecx, ptr[r11d + r15d * 1 + 1]);
            mov(ecx, ptr[r11d + r15d * 1 + 1000]);
            mov(ecx, ptr[r11d + r15d * 1 - 1]);
            mov(ecx, ptr[r11d + r15d * 1 - 1000]);
            mov(ecx, ptr[r11d + r15d * 2 + 0]);
            mov(ecx, ptr[r11d + r15d * 2 + 1]);
            mov(ecx, ptr[r11d + r15d * 2 + 1000]);
            mov(ecx, ptr[r11d + r15d * 2 - 1]);
            mov(ecx, ptr[r11d + r15d * 2 - 1000]);
            mov(ecx, ptr[r11d + r15d * 4 + 0]);
            mov(ecx, ptr[r11d + r15d * 4 + 1]);
            mov(ecx, ptr[r11d + r15d * 4 + 1000]);
            mov(ecx, ptr[r11d + r15d * 4 - 1]);
            mov(ecx, ptr[r11d + r15d * 4 - 1000]);
            mov(ecx, ptr[r11d + r15d * 8 + 0]);
            mov(ecx, ptr[r11d + r15d * 8 + 1]);
            mov(ecx, ptr[r11d + r15d * 8 + 1000]);
            mov(ecx, ptr[r11d + r15d * 8 - 1]);
            mov(ecx, ptr[r11d + r15d * 8 - 1000]);
            mov(ecx, ptr[r12d + eax + 0]);
            mov(ecx, ptr[r12d + eax + 1]);
            mov(ecx, ptr[r12d + eax + 1000]);
            mov(ecx, ptr[r12d + eax - 1]);
            mov(ecx, ptr[r12d + eax - 1000]);
            mov(ecx, ptr[r12d + eax * 1 + 0]);
            mov(ecx, ptr[r12d + eax * 1 + 1]);
            mov(ecx, ptr[r12d + eax * 1 + 1000]);
            mov(ecx, ptr[r12d + eax * 1 - 1]);
            mov(ecx, ptr[r12d + eax * 1 - 1000]);
            mov(ecx, ptr[r12d + eax * 2 + 0]);
            mov(ecx, ptr[r12d + eax * 2 + 1]);
            mov(ecx, ptr[r12d + eax * 2 + 1000]);
            mov(ecx, ptr[r12d + eax * 2 - 1]);
            mov(ecx, ptr[r12d + eax * 2 - 1000]);
            mov(ecx, ptr[r12d + eax * 4 + 0]);
            mov(ecx, ptr[r12d + eax * 4 + 1]);
            mov(ecx, ptr[r12d + eax * 4 + 1000]);
            mov(ecx, ptr[r12d + eax * 4 - 1]);
            mov(ecx, ptr[r12d + eax * 4 - 1000]);
            mov(ecx, ptr[r12d + eax * 8 + 0]);
            mov(ecx, ptr[r12d + eax * 8 + 1]);
            mov(ecx, ptr[r12d + eax * 8 + 1000]);
            mov(ecx, ptr[r12d + eax * 8 - 1]);
            mov(ecx, ptr[r12d + eax * 8 - 1000]);
            mov(ecx, ptr[r12d + ecx + 0]);
            mov(ecx, ptr[r12d + ecx + 1]);
            mov(ecx, ptr[r12d + ecx + 1000]);
            mov(ecx, ptr[r12d + ecx - 1]);
            mov(ecx, ptr[r12d + ecx - 1000]);
            mov(ecx, ptr[r12d + ecx * 1 + 0]);
            mov(ecx, ptr[r12d + ecx * 1 + 1]);
            mov(ecx, ptr[r12d + ecx * 1 + 1000]);
            mov(ecx, ptr[r12d + ecx * 1 - 1]);
            mov(ecx, ptr[r12d + ecx * 1 - 1000]);
            mov(ecx, ptr[r12d + ecx * 2 + 0]);
            mov(ecx, ptr[r12d + ecx * 2 + 1]);
            mov(ecx, ptr[r12d + ecx * 2 + 1000]);
            mov(ecx, ptr[r12d + ecx * 2 - 1]);
            mov(ecx, ptr[r12d + ecx * 2 - 1000]);
            mov(ecx, ptr[r12d + ecx * 4 + 0]);
            mov(ecx, ptr[r12d + ecx * 4 + 1]);
            mov(ecx, ptr[r12d + ecx * 4 + 1000]);
            mov(ecx, ptr[r12d + ecx * 4 - 1]);
            mov(ecx, ptr[r12d + ecx * 4 - 1000]);
            mov(ecx, ptr[r12d + ecx * 8 + 0]);
            mov(ecx, ptr[r12d + ecx * 8 + 1]);
            mov(ecx, ptr[r12d + ecx * 8 + 1000]);
            mov(ecx, ptr[r12d + ecx * 8 - 1]);
            mov(ecx, ptr[r12d + ecx * 8 - 1000]);
        }
    }

    class gen39 : CodeGenerator {
        this()
        {
            mov(ecx, ptr[r12d + edx + 0]);
            mov(ecx, ptr[r12d + edx + 1]);
            mov(ecx, ptr[r12d + edx + 1000]);
            mov(ecx, ptr[r12d + edx - 1]);
            mov(ecx, ptr[r12d + edx - 1000]);
            mov(ecx, ptr[r12d + edx * 1 + 0]);
            mov(ecx, ptr[r12d + edx * 1 + 1]);
            mov(ecx, ptr[r12d + edx * 1 + 1000]);
            mov(ecx, ptr[r12d + edx * 1 - 1]);
            mov(ecx, ptr[r12d + edx * 1 - 1000]);
            mov(ecx, ptr[r12d + edx * 2 + 0]);
            mov(ecx, ptr[r12d + edx * 2 + 1]);
            mov(ecx, ptr[r12d + edx * 2 + 1000]);
            mov(ecx, ptr[r12d + edx * 2 - 1]);
            mov(ecx, ptr[r12d + edx * 2 - 1000]);
            mov(ecx, ptr[r12d + edx * 4 + 0]);
            mov(ecx, ptr[r12d + edx * 4 + 1]);
            mov(ecx, ptr[r12d + edx * 4 + 1000]);
            mov(ecx, ptr[r12d + edx * 4 - 1]);
            mov(ecx, ptr[r12d + edx * 4 - 1000]);
            mov(ecx, ptr[r12d + edx * 8 + 0]);
            mov(ecx, ptr[r12d + edx * 8 + 1]);
            mov(ecx, ptr[r12d + edx * 8 + 1000]);
            mov(ecx, ptr[r12d + edx * 8 - 1]);
            mov(ecx, ptr[r12d + edx * 8 - 1000]);
            mov(ecx, ptr[r12d + ebx + 0]);
            mov(ecx, ptr[r12d + ebx + 1]);
            mov(ecx, ptr[r12d + ebx + 1000]);
            mov(ecx, ptr[r12d + ebx - 1]);
            mov(ecx, ptr[r12d + ebx - 1000]);
            mov(ecx, ptr[r12d + ebx * 1 + 0]);
            mov(ecx, ptr[r12d + ebx * 1 + 1]);
            mov(ecx, ptr[r12d + ebx * 1 + 1000]);
            mov(ecx, ptr[r12d + ebx * 1 - 1]);
            mov(ecx, ptr[r12d + ebx * 1 - 1000]);
            mov(ecx, ptr[r12d + ebx * 2 + 0]);
            mov(ecx, ptr[r12d + ebx * 2 + 1]);
            mov(ecx, ptr[r12d + ebx * 2 + 1000]);
            mov(ecx, ptr[r12d + ebx * 2 - 1]);
            mov(ecx, ptr[r12d + ebx * 2 - 1000]);
            mov(ecx, ptr[r12d + ebx * 4 + 0]);
            mov(ecx, ptr[r12d + ebx * 4 + 1]);
            mov(ecx, ptr[r12d + ebx * 4 + 1000]);
            mov(ecx, ptr[r12d + ebx * 4 - 1]);
            mov(ecx, ptr[r12d + ebx * 4 - 1000]);
            mov(ecx, ptr[r12d + ebx * 8 + 0]);
            mov(ecx, ptr[r12d + ebx * 8 + 1]);
            mov(ecx, ptr[r12d + ebx * 8 + 1000]);
            mov(ecx, ptr[r12d + ebx * 8 - 1]);
            mov(ecx, ptr[r12d + ebx * 8 - 1000]);
            mov(ecx, ptr[r12d + ebp + 0]);
            mov(ecx, ptr[r12d + ebp + 1]);
            mov(ecx, ptr[r12d + ebp + 1000]);
            mov(ecx, ptr[r12d + ebp - 1]);
            mov(ecx, ptr[r12d + ebp - 1000]);
            mov(ecx, ptr[r12d + ebp * 1 + 0]);
            mov(ecx, ptr[r12d + ebp * 1 + 1]);
            mov(ecx, ptr[r12d + ebp * 1 + 1000]);
            mov(ecx, ptr[r12d + ebp * 1 - 1]);
            mov(ecx, ptr[r12d + ebp * 1 - 1000]);
            mov(ecx, ptr[r12d + ebp * 2 + 0]);
            mov(ecx, ptr[r12d + ebp * 2 + 1]);
            mov(ecx, ptr[r12d + ebp * 2 + 1000]);
            mov(ecx, ptr[r12d + ebp * 2 - 1]);
            mov(ecx, ptr[r12d + ebp * 2 - 1000]);
            mov(ecx, ptr[r12d + ebp * 4 + 0]);
            mov(ecx, ptr[r12d + ebp * 4 + 1]);
            mov(ecx, ptr[r12d + ebp * 4 + 1000]);
            mov(ecx, ptr[r12d + ebp * 4 - 1]);
            mov(ecx, ptr[r12d + ebp * 4 - 1000]);
            mov(ecx, ptr[r12d + ebp * 8 + 0]);
            mov(ecx, ptr[r12d + ebp * 8 + 1]);
            mov(ecx, ptr[r12d + ebp * 8 + 1000]);
            mov(ecx, ptr[r12d + ebp * 8 - 1]);
            mov(ecx, ptr[r12d + ebp * 8 - 1000]);
            mov(ecx, ptr[r12d + esi + 0]);
            mov(ecx, ptr[r12d + esi + 1]);
            mov(ecx, ptr[r12d + esi + 1000]);
            mov(ecx, ptr[r12d + esi - 1]);
            mov(ecx, ptr[r12d + esi - 1000]);
            mov(ecx, ptr[r12d + esi * 1 + 0]);
            mov(ecx, ptr[r12d + esi * 1 + 1]);
            mov(ecx, ptr[r12d + esi * 1 + 1000]);
            mov(ecx, ptr[r12d + esi * 1 - 1]);
            mov(ecx, ptr[r12d + esi * 1 - 1000]);
            mov(ecx, ptr[r12d + esi * 2 + 0]);
            mov(ecx, ptr[r12d + esi * 2 + 1]);
            mov(ecx, ptr[r12d + esi * 2 + 1000]);
            mov(ecx, ptr[r12d + esi * 2 - 1]);
            mov(ecx, ptr[r12d + esi * 2 - 1000]);
            mov(ecx, ptr[r12d + esi * 4 + 0]);
            mov(ecx, ptr[r12d + esi * 4 + 1]);
            mov(ecx, ptr[r12d + esi * 4 + 1000]);
            mov(ecx, ptr[r12d + esi * 4 - 1]);
            mov(ecx, ptr[r12d + esi * 4 - 1000]);
            mov(ecx, ptr[r12d + esi * 8 + 0]);
            mov(ecx, ptr[r12d + esi * 8 + 1]);
            mov(ecx, ptr[r12d + esi * 8 + 1000]);
            mov(ecx, ptr[r12d + esi * 8 - 1]);
            mov(ecx, ptr[r12d + esi * 8 - 1000]);
        }
    }

    class gen40 : CodeGenerator {
        this()
        {
            mov(ecx, ptr[r12d + edi + 0]);
            mov(ecx, ptr[r12d + edi + 1]);
            mov(ecx, ptr[r12d + edi + 1000]);
            mov(ecx, ptr[r12d + edi - 1]);
            mov(ecx, ptr[r12d + edi - 1000]);
            mov(ecx, ptr[r12d + edi * 1 + 0]);
            mov(ecx, ptr[r12d + edi * 1 + 1]);
            mov(ecx, ptr[r12d + edi * 1 + 1000]);
            mov(ecx, ptr[r12d + edi * 1 - 1]);
            mov(ecx, ptr[r12d + edi * 1 - 1000]);
            mov(ecx, ptr[r12d + edi * 2 + 0]);
            mov(ecx, ptr[r12d + edi * 2 + 1]);
            mov(ecx, ptr[r12d + edi * 2 + 1000]);
            mov(ecx, ptr[r12d + edi * 2 - 1]);
            mov(ecx, ptr[r12d + edi * 2 - 1000]);
            mov(ecx, ptr[r12d + edi * 4 + 0]);
            mov(ecx, ptr[r12d + edi * 4 + 1]);
            mov(ecx, ptr[r12d + edi * 4 + 1000]);
            mov(ecx, ptr[r12d + edi * 4 - 1]);
            mov(ecx, ptr[r12d + edi * 4 - 1000]);
            mov(ecx, ptr[r12d + edi * 8 + 0]);
            mov(ecx, ptr[r12d + edi * 8 + 1]);
            mov(ecx, ptr[r12d + edi * 8 + 1000]);
            mov(ecx, ptr[r12d + edi * 8 - 1]);
            mov(ecx, ptr[r12d + edi * 8 - 1000]);
            mov(ecx, ptr[r12d + r9d + 0]);
            mov(ecx, ptr[r12d + r9d + 1]);
            mov(ecx, ptr[r12d + r9d + 1000]);
            mov(ecx, ptr[r12d + r9d - 1]);
            mov(ecx, ptr[r12d + r9d - 1000]);
            mov(ecx, ptr[r12d + r9d * 1 + 0]);
            mov(ecx, ptr[r12d + r9d * 1 + 1]);
            mov(ecx, ptr[r12d + r9d * 1 + 1000]);
            mov(ecx, ptr[r12d + r9d * 1 - 1]);
            mov(ecx, ptr[r12d + r9d * 1 - 1000]);
            mov(ecx, ptr[r12d + r9d * 2 + 0]);
            mov(ecx, ptr[r12d + r9d * 2 + 1]);
            mov(ecx, ptr[r12d + r9d * 2 + 1000]);
            mov(ecx, ptr[r12d + r9d * 2 - 1]);
            mov(ecx, ptr[r12d + r9d * 2 - 1000]);
            mov(ecx, ptr[r12d + r9d * 4 + 0]);
            mov(ecx, ptr[r12d + r9d * 4 + 1]);
            mov(ecx, ptr[r12d + r9d * 4 + 1000]);
            mov(ecx, ptr[r12d + r9d * 4 - 1]);
            mov(ecx, ptr[r12d + r9d * 4 - 1000]);
            mov(ecx, ptr[r12d + r9d * 8 + 0]);
            mov(ecx, ptr[r12d + r9d * 8 + 1]);
            mov(ecx, ptr[r12d + r9d * 8 + 1000]);
            mov(ecx, ptr[r12d + r9d * 8 - 1]);
            mov(ecx, ptr[r12d + r9d * 8 - 1000]);
            mov(ecx, ptr[r12d + r10d + 0]);
            mov(ecx, ptr[r12d + r10d + 1]);
            mov(ecx, ptr[r12d + r10d + 1000]);
            mov(ecx, ptr[r12d + r10d - 1]);
            mov(ecx, ptr[r12d + r10d - 1000]);
            mov(ecx, ptr[r12d + r10d * 1 + 0]);
            mov(ecx, ptr[r12d + r10d * 1 + 1]);
            mov(ecx, ptr[r12d + r10d * 1 + 1000]);
            mov(ecx, ptr[r12d + r10d * 1 - 1]);
            mov(ecx, ptr[r12d + r10d * 1 - 1000]);
            mov(ecx, ptr[r12d + r10d * 2 + 0]);
            mov(ecx, ptr[r12d + r10d * 2 + 1]);
            mov(ecx, ptr[r12d + r10d * 2 + 1000]);
            mov(ecx, ptr[r12d + r10d * 2 - 1]);
            mov(ecx, ptr[r12d + r10d * 2 - 1000]);
            mov(ecx, ptr[r12d + r10d * 4 + 0]);
            mov(ecx, ptr[r12d + r10d * 4 + 1]);
            mov(ecx, ptr[r12d + r10d * 4 + 1000]);
            mov(ecx, ptr[r12d + r10d * 4 - 1]);
            mov(ecx, ptr[r12d + r10d * 4 - 1000]);
            mov(ecx, ptr[r12d + r10d * 8 + 0]);
            mov(ecx, ptr[r12d + r10d * 8 + 1]);
            mov(ecx, ptr[r12d + r10d * 8 + 1000]);
            mov(ecx, ptr[r12d + r10d * 8 - 1]);
            mov(ecx, ptr[r12d + r10d * 8 - 1000]);
            mov(ecx, ptr[r12d + r11d + 0]);
            mov(ecx, ptr[r12d + r11d + 1]);
            mov(ecx, ptr[r12d + r11d + 1000]);
            mov(ecx, ptr[r12d + r11d - 1]);
            mov(ecx, ptr[r12d + r11d - 1000]);
            mov(ecx, ptr[r12d + r11d * 1 + 0]);
            mov(ecx, ptr[r12d + r11d * 1 + 1]);
            mov(ecx, ptr[r12d + r11d * 1 + 1000]);
            mov(ecx, ptr[r12d + r11d * 1 - 1]);
            mov(ecx, ptr[r12d + r11d * 1 - 1000]);
            mov(ecx, ptr[r12d + r11d * 2 + 0]);
            mov(ecx, ptr[r12d + r11d * 2 + 1]);
            mov(ecx, ptr[r12d + r11d * 2 + 1000]);
            mov(ecx, ptr[r12d + r11d * 2 - 1]);
            mov(ecx, ptr[r12d + r11d * 2 - 1000]);
            mov(ecx, ptr[r12d + r11d * 4 + 0]);
            mov(ecx, ptr[r12d + r11d * 4 + 1]);
            mov(ecx, ptr[r12d + r11d * 4 + 1000]);
            mov(ecx, ptr[r12d + r11d * 4 - 1]);
            mov(ecx, ptr[r12d + r11d * 4 - 1000]);
            mov(ecx, ptr[r12d + r11d * 8 + 0]);
            mov(ecx, ptr[r12d + r11d * 8 + 1]);
            mov(ecx, ptr[r12d + r11d * 8 + 1000]);
            mov(ecx, ptr[r12d + r11d * 8 - 1]);
            mov(ecx, ptr[r12d + r11d * 8 - 1000]);
        }
    }

    class gen41 : CodeGenerator {
        this()
        {
            mov(ecx, ptr[r12d + r12d + 0]);
            mov(ecx, ptr[r12d + r12d + 1]);
            mov(ecx, ptr[r12d + r12d + 1000]);
            mov(ecx, ptr[r12d + r12d - 1]);
            mov(ecx, ptr[r12d + r12d - 1000]);
            mov(ecx, ptr[r12d + r12d * 1 + 0]);
            mov(ecx, ptr[r12d + r12d * 1 + 1]);
            mov(ecx, ptr[r12d + r12d * 1 + 1000]);
            mov(ecx, ptr[r12d + r12d * 1 - 1]);
            mov(ecx, ptr[r12d + r12d * 1 - 1000]);
            mov(ecx, ptr[r12d + r12d * 2 + 0]);
            mov(ecx, ptr[r12d + r12d * 2 + 1]);
            mov(ecx, ptr[r12d + r12d * 2 + 1000]);
            mov(ecx, ptr[r12d + r12d * 2 - 1]);
            mov(ecx, ptr[r12d + r12d * 2 - 1000]);
            mov(ecx, ptr[r12d + r12d * 4 + 0]);
            mov(ecx, ptr[r12d + r12d * 4 + 1]);
            mov(ecx, ptr[r12d + r12d * 4 + 1000]);
            mov(ecx, ptr[r12d + r12d * 4 - 1]);
            mov(ecx, ptr[r12d + r12d * 4 - 1000]);
            mov(ecx, ptr[r12d + r12d * 8 + 0]);
            mov(ecx, ptr[r12d + r12d * 8 + 1]);
            mov(ecx, ptr[r12d + r12d * 8 + 1000]);
            mov(ecx, ptr[r12d + r12d * 8 - 1]);
            mov(ecx, ptr[r12d + r12d * 8 - 1000]);
            mov(ecx, ptr[r12d + r13d + 0]);
            mov(ecx, ptr[r12d + r13d + 1]);
            mov(ecx, ptr[r12d + r13d + 1000]);
            mov(ecx, ptr[r12d + r13d - 1]);
            mov(ecx, ptr[r12d + r13d - 1000]);
            mov(ecx, ptr[r12d + r13d * 1 + 0]);
            mov(ecx, ptr[r12d + r13d * 1 + 1]);
            mov(ecx, ptr[r12d + r13d * 1 + 1000]);
            mov(ecx, ptr[r12d + r13d * 1 - 1]);
            mov(ecx, ptr[r12d + r13d * 1 - 1000]);
            mov(ecx, ptr[r12d + r13d * 2 + 0]);
            mov(ecx, ptr[r12d + r13d * 2 + 1]);
            mov(ecx, ptr[r12d + r13d * 2 + 1000]);
            mov(ecx, ptr[r12d + r13d * 2 - 1]);
            mov(ecx, ptr[r12d + r13d * 2 - 1000]);
            mov(ecx, ptr[r12d + r13d * 4 + 0]);
            mov(ecx, ptr[r12d + r13d * 4 + 1]);
            mov(ecx, ptr[r12d + r13d * 4 + 1000]);
            mov(ecx, ptr[r12d + r13d * 4 - 1]);
            mov(ecx, ptr[r12d + r13d * 4 - 1000]);
            mov(ecx, ptr[r12d + r13d * 8 + 0]);
            mov(ecx, ptr[r12d + r13d * 8 + 1]);
            mov(ecx, ptr[r12d + r13d * 8 + 1000]);
            mov(ecx, ptr[r12d + r13d * 8 - 1]);
            mov(ecx, ptr[r12d + r13d * 8 - 1000]);
            mov(ecx, ptr[r12d + r14d + 0]);
            mov(ecx, ptr[r12d + r14d + 1]);
            mov(ecx, ptr[r12d + r14d + 1000]);
            mov(ecx, ptr[r12d + r14d - 1]);
            mov(ecx, ptr[r12d + r14d - 1000]);
            mov(ecx, ptr[r12d + r14d * 1 + 0]);
            mov(ecx, ptr[r12d + r14d * 1 + 1]);
            mov(ecx, ptr[r12d + r14d * 1 + 1000]);
            mov(ecx, ptr[r12d + r14d * 1 - 1]);
            mov(ecx, ptr[r12d + r14d * 1 - 1000]);
            mov(ecx, ptr[r12d + r14d * 2 + 0]);
            mov(ecx, ptr[r12d + r14d * 2 + 1]);
            mov(ecx, ptr[r12d + r14d * 2 + 1000]);
            mov(ecx, ptr[r12d + r14d * 2 - 1]);
            mov(ecx, ptr[r12d + r14d * 2 - 1000]);
            mov(ecx, ptr[r12d + r14d * 4 + 0]);
            mov(ecx, ptr[r12d + r14d * 4 + 1]);
            mov(ecx, ptr[r12d + r14d * 4 + 1000]);
            mov(ecx, ptr[r12d + r14d * 4 - 1]);
            mov(ecx, ptr[r12d + r14d * 4 - 1000]);
            mov(ecx, ptr[r12d + r14d * 8 + 0]);
            mov(ecx, ptr[r12d + r14d * 8 + 1]);
            mov(ecx, ptr[r12d + r14d * 8 + 1000]);
            mov(ecx, ptr[r12d + r14d * 8 - 1]);
            mov(ecx, ptr[r12d + r14d * 8 - 1000]);
            mov(ecx, ptr[r12d + r15d + 0]);
            mov(ecx, ptr[r12d + r15d + 1]);
            mov(ecx, ptr[r12d + r15d + 1000]);
            mov(ecx, ptr[r12d + r15d - 1]);
            mov(ecx, ptr[r12d + r15d - 1000]);
            mov(ecx, ptr[r12d + r15d * 1 + 0]);
            mov(ecx, ptr[r12d + r15d * 1 + 1]);
            mov(ecx, ptr[r12d + r15d * 1 + 1000]);
            mov(ecx, ptr[r12d + r15d * 1 - 1]);
            mov(ecx, ptr[r12d + r15d * 1 - 1000]);
            mov(ecx, ptr[r12d + r15d * 2 + 0]);
            mov(ecx, ptr[r12d + r15d * 2 + 1]);
            mov(ecx, ptr[r12d + r15d * 2 + 1000]);
            mov(ecx, ptr[r12d + r15d * 2 - 1]);
            mov(ecx, ptr[r12d + r15d * 2 - 1000]);
            mov(ecx, ptr[r12d + r15d * 4 + 0]);
            mov(ecx, ptr[r12d + r15d * 4 + 1]);
            mov(ecx, ptr[r12d + r15d * 4 + 1000]);
            mov(ecx, ptr[r12d + r15d * 4 - 1]);
            mov(ecx, ptr[r12d + r15d * 4 - 1000]);
            mov(ecx, ptr[r12d + r15d * 8 + 0]);
            mov(ecx, ptr[r12d + r15d * 8 + 1]);
            mov(ecx, ptr[r12d + r15d * 8 + 1000]);
            mov(ecx, ptr[r12d + r15d * 8 - 1]);
            mov(ecx, ptr[r12d + r15d * 8 - 1000]);
        }
    }

    class gen42 : CodeGenerator {
        this()
        {
            mov(ecx, ptr[r13d + eax + 0]);
            mov(ecx, ptr[r13d + eax + 1]);
            mov(ecx, ptr[r13d + eax + 1000]);
            mov(ecx, ptr[r13d + eax - 1]);
            mov(ecx, ptr[r13d + eax - 1000]);
            mov(ecx, ptr[r13d + eax * 1 + 0]);
            mov(ecx, ptr[r13d + eax * 1 + 1]);
            mov(ecx, ptr[r13d + eax * 1 + 1000]);
            mov(ecx, ptr[r13d + eax * 1 - 1]);
            mov(ecx, ptr[r13d + eax * 1 - 1000]);
            mov(ecx, ptr[r13d + eax * 2 + 0]);
            mov(ecx, ptr[r13d + eax * 2 + 1]);
            mov(ecx, ptr[r13d + eax * 2 + 1000]);
            mov(ecx, ptr[r13d + eax * 2 - 1]);
            mov(ecx, ptr[r13d + eax * 2 - 1000]);
            mov(ecx, ptr[r13d + eax * 4 + 0]);
            mov(ecx, ptr[r13d + eax * 4 + 1]);
            mov(ecx, ptr[r13d + eax * 4 + 1000]);
            mov(ecx, ptr[r13d + eax * 4 - 1]);
            mov(ecx, ptr[r13d + eax * 4 - 1000]);
            mov(ecx, ptr[r13d + eax * 8 + 0]);
            mov(ecx, ptr[r13d + eax * 8 + 1]);
            mov(ecx, ptr[r13d + eax * 8 + 1000]);
            mov(ecx, ptr[r13d + eax * 8 - 1]);
            mov(ecx, ptr[r13d + eax * 8 - 1000]);
            mov(ecx, ptr[r13d + ecx + 0]);
            mov(ecx, ptr[r13d + ecx + 1]);
            mov(ecx, ptr[r13d + ecx + 1000]);
            mov(ecx, ptr[r13d + ecx - 1]);
            mov(ecx, ptr[r13d + ecx - 1000]);
            mov(ecx, ptr[r13d + ecx * 1 + 0]);
            mov(ecx, ptr[r13d + ecx * 1 + 1]);
            mov(ecx, ptr[r13d + ecx * 1 + 1000]);
            mov(ecx, ptr[r13d + ecx * 1 - 1]);
            mov(ecx, ptr[r13d + ecx * 1 - 1000]);
            mov(ecx, ptr[r13d + ecx * 2 + 0]);
            mov(ecx, ptr[r13d + ecx * 2 + 1]);
            mov(ecx, ptr[r13d + ecx * 2 + 1000]);
            mov(ecx, ptr[r13d + ecx * 2 - 1]);
            mov(ecx, ptr[r13d + ecx * 2 - 1000]);
            mov(ecx, ptr[r13d + ecx * 4 + 0]);
            mov(ecx, ptr[r13d + ecx * 4 + 1]);
            mov(ecx, ptr[r13d + ecx * 4 + 1000]);
            mov(ecx, ptr[r13d + ecx * 4 - 1]);
            mov(ecx, ptr[r13d + ecx * 4 - 1000]);
            mov(ecx, ptr[r13d + ecx * 8 + 0]);
            mov(ecx, ptr[r13d + ecx * 8 + 1]);
            mov(ecx, ptr[r13d + ecx * 8 + 1000]);
            mov(ecx, ptr[r13d + ecx * 8 - 1]);
            mov(ecx, ptr[r13d + ecx * 8 - 1000]);
            mov(ecx, ptr[r13d + edx + 0]);
            mov(ecx, ptr[r13d + edx + 1]);
            mov(ecx, ptr[r13d + edx + 1000]);
            mov(ecx, ptr[r13d + edx - 1]);
            mov(ecx, ptr[r13d + edx - 1000]);
            mov(ecx, ptr[r13d + edx * 1 + 0]);
            mov(ecx, ptr[r13d + edx * 1 + 1]);
            mov(ecx, ptr[r13d + edx * 1 + 1000]);
            mov(ecx, ptr[r13d + edx * 1 - 1]);
            mov(ecx, ptr[r13d + edx * 1 - 1000]);
            mov(ecx, ptr[r13d + edx * 2 + 0]);
            mov(ecx, ptr[r13d + edx * 2 + 1]);
            mov(ecx, ptr[r13d + edx * 2 + 1000]);
            mov(ecx, ptr[r13d + edx * 2 - 1]);
            mov(ecx, ptr[r13d + edx * 2 - 1000]);
            mov(ecx, ptr[r13d + edx * 4 + 0]);
            mov(ecx, ptr[r13d + edx * 4 + 1]);
            mov(ecx, ptr[r13d + edx * 4 + 1000]);
            mov(ecx, ptr[r13d + edx * 4 - 1]);
            mov(ecx, ptr[r13d + edx * 4 - 1000]);
            mov(ecx, ptr[r13d + edx * 8 + 0]);
            mov(ecx, ptr[r13d + edx * 8 + 1]);
            mov(ecx, ptr[r13d + edx * 8 + 1000]);
            mov(ecx, ptr[r13d + edx * 8 - 1]);
            mov(ecx, ptr[r13d + edx * 8 - 1000]);
            mov(ecx, ptr[r13d + ebx + 0]);
            mov(ecx, ptr[r13d + ebx + 1]);
            mov(ecx, ptr[r13d + ebx + 1000]);
            mov(ecx, ptr[r13d + ebx - 1]);
            mov(ecx, ptr[r13d + ebx - 1000]);
            mov(ecx, ptr[r13d + ebx * 1 + 0]);
            mov(ecx, ptr[r13d + ebx * 1 + 1]);
            mov(ecx, ptr[r13d + ebx * 1 + 1000]);
            mov(ecx, ptr[r13d + ebx * 1 - 1]);
            mov(ecx, ptr[r13d + ebx * 1 - 1000]);
            mov(ecx, ptr[r13d + ebx * 2 + 0]);
            mov(ecx, ptr[r13d + ebx * 2 + 1]);
            mov(ecx, ptr[r13d + ebx * 2 + 1000]);
            mov(ecx, ptr[r13d + ebx * 2 - 1]);
            mov(ecx, ptr[r13d + ebx * 2 - 1000]);
            mov(ecx, ptr[r13d + ebx * 4 + 0]);
            mov(ecx, ptr[r13d + ebx * 4 + 1]);
            mov(ecx, ptr[r13d + ebx * 4 + 1000]);
            mov(ecx, ptr[r13d + ebx * 4 - 1]);
            mov(ecx, ptr[r13d + ebx * 4 - 1000]);
            mov(ecx, ptr[r13d + ebx * 8 + 0]);
            mov(ecx, ptr[r13d + ebx * 8 + 1]);
            mov(ecx, ptr[r13d + ebx * 8 + 1000]);
            mov(ecx, ptr[r13d + ebx * 8 - 1]);
            mov(ecx, ptr[r13d + ebx * 8 - 1000]);
        }
    }

    class gen43 : CodeGenerator {
        this()
        {
            mov(ecx, ptr[r13d + ebp + 0]);
            mov(ecx, ptr[r13d + ebp + 1]);
            mov(ecx, ptr[r13d + ebp + 1000]);
            mov(ecx, ptr[r13d + ebp - 1]);
            mov(ecx, ptr[r13d + ebp - 1000]);
            mov(ecx, ptr[r13d + ebp * 1 + 0]);
            mov(ecx, ptr[r13d + ebp * 1 + 1]);
            mov(ecx, ptr[r13d + ebp * 1 + 1000]);
            mov(ecx, ptr[r13d + ebp * 1 - 1]);
            mov(ecx, ptr[r13d + ebp * 1 - 1000]);
            mov(ecx, ptr[r13d + ebp * 2 + 0]);
            mov(ecx, ptr[r13d + ebp * 2 + 1]);
            mov(ecx, ptr[r13d + ebp * 2 + 1000]);
            mov(ecx, ptr[r13d + ebp * 2 - 1]);
            mov(ecx, ptr[r13d + ebp * 2 - 1000]);
            mov(ecx, ptr[r13d + ebp * 4 + 0]);
            mov(ecx, ptr[r13d + ebp * 4 + 1]);
            mov(ecx, ptr[r13d + ebp * 4 + 1000]);
            mov(ecx, ptr[r13d + ebp * 4 - 1]);
            mov(ecx, ptr[r13d + ebp * 4 - 1000]);
            mov(ecx, ptr[r13d + ebp * 8 + 0]);
            mov(ecx, ptr[r13d + ebp * 8 + 1]);
            mov(ecx, ptr[r13d + ebp * 8 + 1000]);
            mov(ecx, ptr[r13d + ebp * 8 - 1]);
            mov(ecx, ptr[r13d + ebp * 8 - 1000]);
            mov(ecx, ptr[r13d + esi + 0]);
            mov(ecx, ptr[r13d + esi + 1]);
            mov(ecx, ptr[r13d + esi + 1000]);
            mov(ecx, ptr[r13d + esi - 1]);
            mov(ecx, ptr[r13d + esi - 1000]);
            mov(ecx, ptr[r13d + esi * 1 + 0]);
            mov(ecx, ptr[r13d + esi * 1 + 1]);
            mov(ecx, ptr[r13d + esi * 1 + 1000]);
            mov(ecx, ptr[r13d + esi * 1 - 1]);
            mov(ecx, ptr[r13d + esi * 1 - 1000]);
            mov(ecx, ptr[r13d + esi * 2 + 0]);
            mov(ecx, ptr[r13d + esi * 2 + 1]);
            mov(ecx, ptr[r13d + esi * 2 + 1000]);
            mov(ecx, ptr[r13d + esi * 2 - 1]);
            mov(ecx, ptr[r13d + esi * 2 - 1000]);
            mov(ecx, ptr[r13d + esi * 4 + 0]);
            mov(ecx, ptr[r13d + esi * 4 + 1]);
            mov(ecx, ptr[r13d + esi * 4 + 1000]);
            mov(ecx, ptr[r13d + esi * 4 - 1]);
            mov(ecx, ptr[r13d + esi * 4 - 1000]);
            mov(ecx, ptr[r13d + esi * 8 + 0]);
            mov(ecx, ptr[r13d + esi * 8 + 1]);
            mov(ecx, ptr[r13d + esi * 8 + 1000]);
            mov(ecx, ptr[r13d + esi * 8 - 1]);
            mov(ecx, ptr[r13d + esi * 8 - 1000]);
            mov(ecx, ptr[r13d + edi + 0]);
            mov(ecx, ptr[r13d + edi + 1]);
            mov(ecx, ptr[r13d + edi + 1000]);
            mov(ecx, ptr[r13d + edi - 1]);
            mov(ecx, ptr[r13d + edi - 1000]);
            mov(ecx, ptr[r13d + edi * 1 + 0]);
            mov(ecx, ptr[r13d + edi * 1 + 1]);
            mov(ecx, ptr[r13d + edi * 1 + 1000]);
            mov(ecx, ptr[r13d + edi * 1 - 1]);
            mov(ecx, ptr[r13d + edi * 1 - 1000]);
            mov(ecx, ptr[r13d + edi * 2 + 0]);
            mov(ecx, ptr[r13d + edi * 2 + 1]);
            mov(ecx, ptr[r13d + edi * 2 + 1000]);
            mov(ecx, ptr[r13d + edi * 2 - 1]);
            mov(ecx, ptr[r13d + edi * 2 - 1000]);
            mov(ecx, ptr[r13d + edi * 4 + 0]);
            mov(ecx, ptr[r13d + edi * 4 + 1]);
            mov(ecx, ptr[r13d + edi * 4 + 1000]);
            mov(ecx, ptr[r13d + edi * 4 - 1]);
            mov(ecx, ptr[r13d + edi * 4 - 1000]);
            mov(ecx, ptr[r13d + edi * 8 + 0]);
            mov(ecx, ptr[r13d + edi * 8 + 1]);
            mov(ecx, ptr[r13d + edi * 8 + 1000]);
            mov(ecx, ptr[r13d + edi * 8 - 1]);
            mov(ecx, ptr[r13d + edi * 8 - 1000]);
            mov(ecx, ptr[r13d + r9d + 0]);
            mov(ecx, ptr[r13d + r9d + 1]);
            mov(ecx, ptr[r13d + r9d + 1000]);
            mov(ecx, ptr[r13d + r9d - 1]);
            mov(ecx, ptr[r13d + r9d - 1000]);
            mov(ecx, ptr[r13d + r9d * 1 + 0]);
            mov(ecx, ptr[r13d + r9d * 1 + 1]);
            mov(ecx, ptr[r13d + r9d * 1 + 1000]);
            mov(ecx, ptr[r13d + r9d * 1 - 1]);
            mov(ecx, ptr[r13d + r9d * 1 - 1000]);
            mov(ecx, ptr[r13d + r9d * 2 + 0]);
            mov(ecx, ptr[r13d + r9d * 2 + 1]);
            mov(ecx, ptr[r13d + r9d * 2 + 1000]);
            mov(ecx, ptr[r13d + r9d * 2 - 1]);
            mov(ecx, ptr[r13d + r9d * 2 - 1000]);
            mov(ecx, ptr[r13d + r9d * 4 + 0]);
            mov(ecx, ptr[r13d + r9d * 4 + 1]);
            mov(ecx, ptr[r13d + r9d * 4 + 1000]);
            mov(ecx, ptr[r13d + r9d * 4 - 1]);
            mov(ecx, ptr[r13d + r9d * 4 - 1000]);
            mov(ecx, ptr[r13d + r9d * 8 + 0]);
            mov(ecx, ptr[r13d + r9d * 8 + 1]);
            mov(ecx, ptr[r13d + r9d * 8 + 1000]);
            mov(ecx, ptr[r13d + r9d * 8 - 1]);
            mov(ecx, ptr[r13d + r9d * 8 - 1000]);
        }
    }

    class gen44 : CodeGenerator {
        this()
        {
            mov(ecx, ptr[r13d + r10d + 0]);
            mov(ecx, ptr[r13d + r10d + 1]);
            mov(ecx, ptr[r13d + r10d + 1000]);
            mov(ecx, ptr[r13d + r10d - 1]);
            mov(ecx, ptr[r13d + r10d - 1000]);
            mov(ecx, ptr[r13d + r10d * 1 + 0]);
            mov(ecx, ptr[r13d + r10d * 1 + 1]);
            mov(ecx, ptr[r13d + r10d * 1 + 1000]);
            mov(ecx, ptr[r13d + r10d * 1 - 1]);
            mov(ecx, ptr[r13d + r10d * 1 - 1000]);
            mov(ecx, ptr[r13d + r10d * 2 + 0]);
            mov(ecx, ptr[r13d + r10d * 2 + 1]);
            mov(ecx, ptr[r13d + r10d * 2 + 1000]);
            mov(ecx, ptr[r13d + r10d * 2 - 1]);
            mov(ecx, ptr[r13d + r10d * 2 - 1000]);
            mov(ecx, ptr[r13d + r10d * 4 + 0]);
            mov(ecx, ptr[r13d + r10d * 4 + 1]);
            mov(ecx, ptr[r13d + r10d * 4 + 1000]);
            mov(ecx, ptr[r13d + r10d * 4 - 1]);
            mov(ecx, ptr[r13d + r10d * 4 - 1000]);
            mov(ecx, ptr[r13d + r10d * 8 + 0]);
            mov(ecx, ptr[r13d + r10d * 8 + 1]);
            mov(ecx, ptr[r13d + r10d * 8 + 1000]);
            mov(ecx, ptr[r13d + r10d * 8 - 1]);
            mov(ecx, ptr[r13d + r10d * 8 - 1000]);
            mov(ecx, ptr[r13d + r11d + 0]);
            mov(ecx, ptr[r13d + r11d + 1]);
            mov(ecx, ptr[r13d + r11d + 1000]);
            mov(ecx, ptr[r13d + r11d - 1]);
            mov(ecx, ptr[r13d + r11d - 1000]);
            mov(ecx, ptr[r13d + r11d * 1 + 0]);
            mov(ecx, ptr[r13d + r11d * 1 + 1]);
            mov(ecx, ptr[r13d + r11d * 1 + 1000]);
            mov(ecx, ptr[r13d + r11d * 1 - 1]);
            mov(ecx, ptr[r13d + r11d * 1 - 1000]);
            mov(ecx, ptr[r13d + r11d * 2 + 0]);
            mov(ecx, ptr[r13d + r11d * 2 + 1]);
            mov(ecx, ptr[r13d + r11d * 2 + 1000]);
            mov(ecx, ptr[r13d + r11d * 2 - 1]);
            mov(ecx, ptr[r13d + r11d * 2 - 1000]);
            mov(ecx, ptr[r13d + r11d * 4 + 0]);
            mov(ecx, ptr[r13d + r11d * 4 + 1]);
            mov(ecx, ptr[r13d + r11d * 4 + 1000]);
            mov(ecx, ptr[r13d + r11d * 4 - 1]);
            mov(ecx, ptr[r13d + r11d * 4 - 1000]);
            mov(ecx, ptr[r13d + r11d * 8 + 0]);
            mov(ecx, ptr[r13d + r11d * 8 + 1]);
            mov(ecx, ptr[r13d + r11d * 8 + 1000]);
            mov(ecx, ptr[r13d + r11d * 8 - 1]);
            mov(ecx, ptr[r13d + r11d * 8 - 1000]);
            mov(ecx, ptr[r13d + r12d + 0]);
            mov(ecx, ptr[r13d + r12d + 1]);
            mov(ecx, ptr[r13d + r12d + 1000]);
            mov(ecx, ptr[r13d + r12d - 1]);
            mov(ecx, ptr[r13d + r12d - 1000]);
            mov(ecx, ptr[r13d + r12d * 1 + 0]);
            mov(ecx, ptr[r13d + r12d * 1 + 1]);
            mov(ecx, ptr[r13d + r12d * 1 + 1000]);
            mov(ecx, ptr[r13d + r12d * 1 - 1]);
            mov(ecx, ptr[r13d + r12d * 1 - 1000]);
            mov(ecx, ptr[r13d + r12d * 2 + 0]);
            mov(ecx, ptr[r13d + r12d * 2 + 1]);
            mov(ecx, ptr[r13d + r12d * 2 + 1000]);
            mov(ecx, ptr[r13d + r12d * 2 - 1]);
            mov(ecx, ptr[r13d + r12d * 2 - 1000]);
            mov(ecx, ptr[r13d + r12d * 4 + 0]);
            mov(ecx, ptr[r13d + r12d * 4 + 1]);
            mov(ecx, ptr[r13d + r12d * 4 + 1000]);
            mov(ecx, ptr[r13d + r12d * 4 - 1]);
            mov(ecx, ptr[r13d + r12d * 4 - 1000]);
            mov(ecx, ptr[r13d + r12d * 8 + 0]);
            mov(ecx, ptr[r13d + r12d * 8 + 1]);
            mov(ecx, ptr[r13d + r12d * 8 + 1000]);
            mov(ecx, ptr[r13d + r12d * 8 - 1]);
            mov(ecx, ptr[r13d + r12d * 8 - 1000]);
            mov(ecx, ptr[r13d + r13d + 0]);
            mov(ecx, ptr[r13d + r13d + 1]);
            mov(ecx, ptr[r13d + r13d + 1000]);
            mov(ecx, ptr[r13d + r13d - 1]);
            mov(ecx, ptr[r13d + r13d - 1000]);
            mov(ecx, ptr[r13d + r13d * 1 + 0]);
            mov(ecx, ptr[r13d + r13d * 1 + 1]);
            mov(ecx, ptr[r13d + r13d * 1 + 1000]);
            mov(ecx, ptr[r13d + r13d * 1 - 1]);
            mov(ecx, ptr[r13d + r13d * 1 - 1000]);
            mov(ecx, ptr[r13d + r13d * 2 + 0]);
            mov(ecx, ptr[r13d + r13d * 2 + 1]);
            mov(ecx, ptr[r13d + r13d * 2 + 1000]);
            mov(ecx, ptr[r13d + r13d * 2 - 1]);
            mov(ecx, ptr[r13d + r13d * 2 - 1000]);
            mov(ecx, ptr[r13d + r13d * 4 + 0]);
            mov(ecx, ptr[r13d + r13d * 4 + 1]);
            mov(ecx, ptr[r13d + r13d * 4 + 1000]);
            mov(ecx, ptr[r13d + r13d * 4 - 1]);
            mov(ecx, ptr[r13d + r13d * 4 - 1000]);
            mov(ecx, ptr[r13d + r13d * 8 + 0]);
            mov(ecx, ptr[r13d + r13d * 8 + 1]);
            mov(ecx, ptr[r13d + r13d * 8 + 1000]);
            mov(ecx, ptr[r13d + r13d * 8 - 1]);
            mov(ecx, ptr[r13d + r13d * 8 - 1000]);
        }
    }

    class gen45 : CodeGenerator {
        this()
        {
            mov(ecx, ptr[r13d + r14d + 0]);
            mov(ecx, ptr[r13d + r14d + 1]);
            mov(ecx, ptr[r13d + r14d + 1000]);
            mov(ecx, ptr[r13d + r14d - 1]);
            mov(ecx, ptr[r13d + r14d - 1000]);
            mov(ecx, ptr[r13d + r14d * 1 + 0]);
            mov(ecx, ptr[r13d + r14d * 1 + 1]);
            mov(ecx, ptr[r13d + r14d * 1 + 1000]);
            mov(ecx, ptr[r13d + r14d * 1 - 1]);
            mov(ecx, ptr[r13d + r14d * 1 - 1000]);
            mov(ecx, ptr[r13d + r14d * 2 + 0]);
            mov(ecx, ptr[r13d + r14d * 2 + 1]);
            mov(ecx, ptr[r13d + r14d * 2 + 1000]);
            mov(ecx, ptr[r13d + r14d * 2 - 1]);
            mov(ecx, ptr[r13d + r14d * 2 - 1000]);
            mov(ecx, ptr[r13d + r14d * 4 + 0]);
            mov(ecx, ptr[r13d + r14d * 4 + 1]);
            mov(ecx, ptr[r13d + r14d * 4 + 1000]);
            mov(ecx, ptr[r13d + r14d * 4 - 1]);
            mov(ecx, ptr[r13d + r14d * 4 - 1000]);
            mov(ecx, ptr[r13d + r14d * 8 + 0]);
            mov(ecx, ptr[r13d + r14d * 8 + 1]);
            mov(ecx, ptr[r13d + r14d * 8 + 1000]);
            mov(ecx, ptr[r13d + r14d * 8 - 1]);
            mov(ecx, ptr[r13d + r14d * 8 - 1000]);
            mov(ecx, ptr[r13d + r15d + 0]);
            mov(ecx, ptr[r13d + r15d + 1]);
            mov(ecx, ptr[r13d + r15d + 1000]);
            mov(ecx, ptr[r13d + r15d - 1]);
            mov(ecx, ptr[r13d + r15d - 1000]);
            mov(ecx, ptr[r13d + r15d * 1 + 0]);
            mov(ecx, ptr[r13d + r15d * 1 + 1]);
            mov(ecx, ptr[r13d + r15d * 1 + 1000]);
            mov(ecx, ptr[r13d + r15d * 1 - 1]);
            mov(ecx, ptr[r13d + r15d * 1 - 1000]);
            mov(ecx, ptr[r13d + r15d * 2 + 0]);
            mov(ecx, ptr[r13d + r15d * 2 + 1]);
            mov(ecx, ptr[r13d + r15d * 2 + 1000]);
            mov(ecx, ptr[r13d + r15d * 2 - 1]);
            mov(ecx, ptr[r13d + r15d * 2 - 1000]);
            mov(ecx, ptr[r13d + r15d * 4 + 0]);
            mov(ecx, ptr[r13d + r15d * 4 + 1]);
            mov(ecx, ptr[r13d + r15d * 4 + 1000]);
            mov(ecx, ptr[r13d + r15d * 4 - 1]);
            mov(ecx, ptr[r13d + r15d * 4 - 1000]);
            mov(ecx, ptr[r13d + r15d * 8 + 0]);
            mov(ecx, ptr[r13d + r15d * 8 + 1]);
            mov(ecx, ptr[r13d + r15d * 8 + 1000]);
            mov(ecx, ptr[r13d + r15d * 8 - 1]);
            mov(ecx, ptr[r13d + r15d * 8 - 1000]);
            mov(ecx, ptr[r14d + eax + 0]);
            mov(ecx, ptr[r14d + eax + 1]);
            mov(ecx, ptr[r14d + eax + 1000]);
            mov(ecx, ptr[r14d + eax - 1]);
            mov(ecx, ptr[r14d + eax - 1000]);
            mov(ecx, ptr[r14d + eax * 1 + 0]);
            mov(ecx, ptr[r14d + eax * 1 + 1]);
            mov(ecx, ptr[r14d + eax * 1 + 1000]);
            mov(ecx, ptr[r14d + eax * 1 - 1]);
            mov(ecx, ptr[r14d + eax * 1 - 1000]);
            mov(ecx, ptr[r14d + eax * 2 + 0]);
            mov(ecx, ptr[r14d + eax * 2 + 1]);
            mov(ecx, ptr[r14d + eax * 2 + 1000]);
            mov(ecx, ptr[r14d + eax * 2 - 1]);
            mov(ecx, ptr[r14d + eax * 2 - 1000]);
            mov(ecx, ptr[r14d + eax * 4 + 0]);
            mov(ecx, ptr[r14d + eax * 4 + 1]);
            mov(ecx, ptr[r14d + eax * 4 + 1000]);
            mov(ecx, ptr[r14d + eax * 4 - 1]);
            mov(ecx, ptr[r14d + eax * 4 - 1000]);
            mov(ecx, ptr[r14d + eax * 8 + 0]);
            mov(ecx, ptr[r14d + eax * 8 + 1]);
            mov(ecx, ptr[r14d + eax * 8 + 1000]);
            mov(ecx, ptr[r14d + eax * 8 - 1]);
            mov(ecx, ptr[r14d + eax * 8 - 1000]);
            mov(ecx, ptr[r14d + ecx + 0]);
            mov(ecx, ptr[r14d + ecx + 1]);
            mov(ecx, ptr[r14d + ecx + 1000]);
            mov(ecx, ptr[r14d + ecx - 1]);
            mov(ecx, ptr[r14d + ecx - 1000]);
            mov(ecx, ptr[r14d + ecx * 1 + 0]);
            mov(ecx, ptr[r14d + ecx * 1 + 1]);
            mov(ecx, ptr[r14d + ecx * 1 + 1000]);
            mov(ecx, ptr[r14d + ecx * 1 - 1]);
            mov(ecx, ptr[r14d + ecx * 1 - 1000]);
            mov(ecx, ptr[r14d + ecx * 2 + 0]);
            mov(ecx, ptr[r14d + ecx * 2 + 1]);
            mov(ecx, ptr[r14d + ecx * 2 + 1000]);
            mov(ecx, ptr[r14d + ecx * 2 - 1]);
            mov(ecx, ptr[r14d + ecx * 2 - 1000]);
            mov(ecx, ptr[r14d + ecx * 4 + 0]);
            mov(ecx, ptr[r14d + ecx * 4 + 1]);
            mov(ecx, ptr[r14d + ecx * 4 + 1000]);
            mov(ecx, ptr[r14d + ecx * 4 - 1]);
            mov(ecx, ptr[r14d + ecx * 4 - 1000]);
            mov(ecx, ptr[r14d + ecx * 8 + 0]);
            mov(ecx, ptr[r14d + ecx * 8 + 1]);
            mov(ecx, ptr[r14d + ecx * 8 + 1000]);
            mov(ecx, ptr[r14d + ecx * 8 - 1]);
            mov(ecx, ptr[r14d + ecx * 8 - 1000]);
        }
    }

    class gen46 : CodeGenerator {
        this()
        {
            mov(ecx, ptr[r14d + edx + 0]);
            mov(ecx, ptr[r14d + edx + 1]);
            mov(ecx, ptr[r14d + edx + 1000]);
            mov(ecx, ptr[r14d + edx - 1]);
            mov(ecx, ptr[r14d + edx - 1000]);
            mov(ecx, ptr[r14d + edx * 1 + 0]);
            mov(ecx, ptr[r14d + edx * 1 + 1]);
            mov(ecx, ptr[r14d + edx * 1 + 1000]);
            mov(ecx, ptr[r14d + edx * 1 - 1]);
            mov(ecx, ptr[r14d + edx * 1 - 1000]);
            mov(ecx, ptr[r14d + edx * 2 + 0]);
            mov(ecx, ptr[r14d + edx * 2 + 1]);
            mov(ecx, ptr[r14d + edx * 2 + 1000]);
            mov(ecx, ptr[r14d + edx * 2 - 1]);
            mov(ecx, ptr[r14d + edx * 2 - 1000]);
            mov(ecx, ptr[r14d + edx * 4 + 0]);
            mov(ecx, ptr[r14d + edx * 4 + 1]);
            mov(ecx, ptr[r14d + edx * 4 + 1000]);
            mov(ecx, ptr[r14d + edx * 4 - 1]);
            mov(ecx, ptr[r14d + edx * 4 - 1000]);
            mov(ecx, ptr[r14d + edx * 8 + 0]);
            mov(ecx, ptr[r14d + edx * 8 + 1]);
            mov(ecx, ptr[r14d + edx * 8 + 1000]);
            mov(ecx, ptr[r14d + edx * 8 - 1]);
            mov(ecx, ptr[r14d + edx * 8 - 1000]);
            mov(ecx, ptr[r14d + ebx + 0]);
            mov(ecx, ptr[r14d + ebx + 1]);
            mov(ecx, ptr[r14d + ebx + 1000]);
            mov(ecx, ptr[r14d + ebx - 1]);
            mov(ecx, ptr[r14d + ebx - 1000]);
            mov(ecx, ptr[r14d + ebx * 1 + 0]);
            mov(ecx, ptr[r14d + ebx * 1 + 1]);
            mov(ecx, ptr[r14d + ebx * 1 + 1000]);
            mov(ecx, ptr[r14d + ebx * 1 - 1]);
            mov(ecx, ptr[r14d + ebx * 1 - 1000]);
            mov(ecx, ptr[r14d + ebx * 2 + 0]);
            mov(ecx, ptr[r14d + ebx * 2 + 1]);
            mov(ecx, ptr[r14d + ebx * 2 + 1000]);
            mov(ecx, ptr[r14d + ebx * 2 - 1]);
            mov(ecx, ptr[r14d + ebx * 2 - 1000]);
            mov(ecx, ptr[r14d + ebx * 4 + 0]);
            mov(ecx, ptr[r14d + ebx * 4 + 1]);
            mov(ecx, ptr[r14d + ebx * 4 + 1000]);
            mov(ecx, ptr[r14d + ebx * 4 - 1]);
            mov(ecx, ptr[r14d + ebx * 4 - 1000]);
            mov(ecx, ptr[r14d + ebx * 8 + 0]);
            mov(ecx, ptr[r14d + ebx * 8 + 1]);
            mov(ecx, ptr[r14d + ebx * 8 + 1000]);
            mov(ecx, ptr[r14d + ebx * 8 - 1]);
            mov(ecx, ptr[r14d + ebx * 8 - 1000]);
            mov(ecx, ptr[r14d + ebp + 0]);
            mov(ecx, ptr[r14d + ebp + 1]);
            mov(ecx, ptr[r14d + ebp + 1000]);
            mov(ecx, ptr[r14d + ebp - 1]);
            mov(ecx, ptr[r14d + ebp - 1000]);
            mov(ecx, ptr[r14d + ebp * 1 + 0]);
            mov(ecx, ptr[r14d + ebp * 1 + 1]);
            mov(ecx, ptr[r14d + ebp * 1 + 1000]);
            mov(ecx, ptr[r14d + ebp * 1 - 1]);
            mov(ecx, ptr[r14d + ebp * 1 - 1000]);
            mov(ecx, ptr[r14d + ebp * 2 + 0]);
            mov(ecx, ptr[r14d + ebp * 2 + 1]);
            mov(ecx, ptr[r14d + ebp * 2 + 1000]);
            mov(ecx, ptr[r14d + ebp * 2 - 1]);
            mov(ecx, ptr[r14d + ebp * 2 - 1000]);
            mov(ecx, ptr[r14d + ebp * 4 + 0]);
            mov(ecx, ptr[r14d + ebp * 4 + 1]);
            mov(ecx, ptr[r14d + ebp * 4 + 1000]);
            mov(ecx, ptr[r14d + ebp * 4 - 1]);
            mov(ecx, ptr[r14d + ebp * 4 - 1000]);
            mov(ecx, ptr[r14d + ebp * 8 + 0]);
            mov(ecx, ptr[r14d + ebp * 8 + 1]);
            mov(ecx, ptr[r14d + ebp * 8 + 1000]);
            mov(ecx, ptr[r14d + ebp * 8 - 1]);
            mov(ecx, ptr[r14d + ebp * 8 - 1000]);
            mov(ecx, ptr[r14d + esi + 0]);
            mov(ecx, ptr[r14d + esi + 1]);
            mov(ecx, ptr[r14d + esi + 1000]);
            mov(ecx, ptr[r14d + esi - 1]);
            mov(ecx, ptr[r14d + esi - 1000]);
            mov(ecx, ptr[r14d + esi * 1 + 0]);
            mov(ecx, ptr[r14d + esi * 1 + 1]);
            mov(ecx, ptr[r14d + esi * 1 + 1000]);
            mov(ecx, ptr[r14d + esi * 1 - 1]);
            mov(ecx, ptr[r14d + esi * 1 - 1000]);
            mov(ecx, ptr[r14d + esi * 2 + 0]);
            mov(ecx, ptr[r14d + esi * 2 + 1]);
            mov(ecx, ptr[r14d + esi * 2 + 1000]);
            mov(ecx, ptr[r14d + esi * 2 - 1]);
            mov(ecx, ptr[r14d + esi * 2 - 1000]);
            mov(ecx, ptr[r14d + esi * 4 + 0]);
            mov(ecx, ptr[r14d + esi * 4 + 1]);
            mov(ecx, ptr[r14d + esi * 4 + 1000]);
            mov(ecx, ptr[r14d + esi * 4 - 1]);
            mov(ecx, ptr[r14d + esi * 4 - 1000]);
            mov(ecx, ptr[r14d + esi * 8 + 0]);
            mov(ecx, ptr[r14d + esi * 8 + 1]);
            mov(ecx, ptr[r14d + esi * 8 + 1000]);
            mov(ecx, ptr[r14d + esi * 8 - 1]);
            mov(ecx, ptr[r14d + esi * 8 - 1000]);
        }
    }

    class gen47 : CodeGenerator {
        this()
        {
            mov(ecx, ptr[r14d + edi + 0]);
            mov(ecx, ptr[r14d + edi + 1]);
            mov(ecx, ptr[r14d + edi + 1000]);
            mov(ecx, ptr[r14d + edi - 1]);
            mov(ecx, ptr[r14d + edi - 1000]);
            mov(ecx, ptr[r14d + edi * 1 + 0]);
            mov(ecx, ptr[r14d + edi * 1 + 1]);
            mov(ecx, ptr[r14d + edi * 1 + 1000]);
            mov(ecx, ptr[r14d + edi * 1 - 1]);
            mov(ecx, ptr[r14d + edi * 1 - 1000]);
            mov(ecx, ptr[r14d + edi * 2 + 0]);
            mov(ecx, ptr[r14d + edi * 2 + 1]);
            mov(ecx, ptr[r14d + edi * 2 + 1000]);
            mov(ecx, ptr[r14d + edi * 2 - 1]);
            mov(ecx, ptr[r14d + edi * 2 - 1000]);
            mov(ecx, ptr[r14d + edi * 4 + 0]);
            mov(ecx, ptr[r14d + edi * 4 + 1]);
            mov(ecx, ptr[r14d + edi * 4 + 1000]);
            mov(ecx, ptr[r14d + edi * 4 - 1]);
            mov(ecx, ptr[r14d + edi * 4 - 1000]);
            mov(ecx, ptr[r14d + edi * 8 + 0]);
            mov(ecx, ptr[r14d + edi * 8 + 1]);
            mov(ecx, ptr[r14d + edi * 8 + 1000]);
            mov(ecx, ptr[r14d + edi * 8 - 1]);
            mov(ecx, ptr[r14d + edi * 8 - 1000]);
            mov(ecx, ptr[r14d + r9d + 0]);
            mov(ecx, ptr[r14d + r9d + 1]);
            mov(ecx, ptr[r14d + r9d + 1000]);
            mov(ecx, ptr[r14d + r9d - 1]);
            mov(ecx, ptr[r14d + r9d - 1000]);
            mov(ecx, ptr[r14d + r9d * 1 + 0]);
            mov(ecx, ptr[r14d + r9d * 1 + 1]);
            mov(ecx, ptr[r14d + r9d * 1 + 1000]);
            mov(ecx, ptr[r14d + r9d * 1 - 1]);
            mov(ecx, ptr[r14d + r9d * 1 - 1000]);
            mov(ecx, ptr[r14d + r9d * 2 + 0]);
            mov(ecx, ptr[r14d + r9d * 2 + 1]);
            mov(ecx, ptr[r14d + r9d * 2 + 1000]);
            mov(ecx, ptr[r14d + r9d * 2 - 1]);
            mov(ecx, ptr[r14d + r9d * 2 - 1000]);
            mov(ecx, ptr[r14d + r9d * 4 + 0]);
            mov(ecx, ptr[r14d + r9d * 4 + 1]);
            mov(ecx, ptr[r14d + r9d * 4 + 1000]);
            mov(ecx, ptr[r14d + r9d * 4 - 1]);
            mov(ecx, ptr[r14d + r9d * 4 - 1000]);
            mov(ecx, ptr[r14d + r9d * 8 + 0]);
            mov(ecx, ptr[r14d + r9d * 8 + 1]);
            mov(ecx, ptr[r14d + r9d * 8 + 1000]);
            mov(ecx, ptr[r14d + r9d * 8 - 1]);
            mov(ecx, ptr[r14d + r9d * 8 - 1000]);
            mov(ecx, ptr[r14d + r10d + 0]);
            mov(ecx, ptr[r14d + r10d + 1]);
            mov(ecx, ptr[r14d + r10d + 1000]);
            mov(ecx, ptr[r14d + r10d - 1]);
            mov(ecx, ptr[r14d + r10d - 1000]);
            mov(ecx, ptr[r14d + r10d * 1 + 0]);
            mov(ecx, ptr[r14d + r10d * 1 + 1]);
            mov(ecx, ptr[r14d + r10d * 1 + 1000]);
            mov(ecx, ptr[r14d + r10d * 1 - 1]);
            mov(ecx, ptr[r14d + r10d * 1 - 1000]);
            mov(ecx, ptr[r14d + r10d * 2 + 0]);
            mov(ecx, ptr[r14d + r10d * 2 + 1]);
            mov(ecx, ptr[r14d + r10d * 2 + 1000]);
            mov(ecx, ptr[r14d + r10d * 2 - 1]);
            mov(ecx, ptr[r14d + r10d * 2 - 1000]);
            mov(ecx, ptr[r14d + r10d * 4 + 0]);
            mov(ecx, ptr[r14d + r10d * 4 + 1]);
            mov(ecx, ptr[r14d + r10d * 4 + 1000]);
            mov(ecx, ptr[r14d + r10d * 4 - 1]);
            mov(ecx, ptr[r14d + r10d * 4 - 1000]);
            mov(ecx, ptr[r14d + r10d * 8 + 0]);
            mov(ecx, ptr[r14d + r10d * 8 + 1]);
            mov(ecx, ptr[r14d + r10d * 8 + 1000]);
            mov(ecx, ptr[r14d + r10d * 8 - 1]);
            mov(ecx, ptr[r14d + r10d * 8 - 1000]);
            mov(ecx, ptr[r14d + r11d + 0]);
            mov(ecx, ptr[r14d + r11d + 1]);
            mov(ecx, ptr[r14d + r11d + 1000]);
            mov(ecx, ptr[r14d + r11d - 1]);
            mov(ecx, ptr[r14d + r11d - 1000]);
            mov(ecx, ptr[r14d + r11d * 1 + 0]);
            mov(ecx, ptr[r14d + r11d * 1 + 1]);
            mov(ecx, ptr[r14d + r11d * 1 + 1000]);
            mov(ecx, ptr[r14d + r11d * 1 - 1]);
            mov(ecx, ptr[r14d + r11d * 1 - 1000]);
            mov(ecx, ptr[r14d + r11d * 2 + 0]);
            mov(ecx, ptr[r14d + r11d * 2 + 1]);
            mov(ecx, ptr[r14d + r11d * 2 + 1000]);
            mov(ecx, ptr[r14d + r11d * 2 - 1]);
            mov(ecx, ptr[r14d + r11d * 2 - 1000]);
            mov(ecx, ptr[r14d + r11d * 4 + 0]);
            mov(ecx, ptr[r14d + r11d * 4 + 1]);
            mov(ecx, ptr[r14d + r11d * 4 + 1000]);
            mov(ecx, ptr[r14d + r11d * 4 - 1]);
            mov(ecx, ptr[r14d + r11d * 4 - 1000]);
            mov(ecx, ptr[r14d + r11d * 8 + 0]);
            mov(ecx, ptr[r14d + r11d * 8 + 1]);
            mov(ecx, ptr[r14d + r11d * 8 + 1000]);
            mov(ecx, ptr[r14d + r11d * 8 - 1]);
            mov(ecx, ptr[r14d + r11d * 8 - 1000]);
        }
    }

    class gen48 : CodeGenerator {
        this()
        {
            mov(ecx, ptr[r14d + r12d + 0]);
            mov(ecx, ptr[r14d + r12d + 1]);
            mov(ecx, ptr[r14d + r12d + 1000]);
            mov(ecx, ptr[r14d + r12d - 1]);
            mov(ecx, ptr[r14d + r12d - 1000]);
            mov(ecx, ptr[r14d + r12d * 1 + 0]);
            mov(ecx, ptr[r14d + r12d * 1 + 1]);
            mov(ecx, ptr[r14d + r12d * 1 + 1000]);
            mov(ecx, ptr[r14d + r12d * 1 - 1]);
            mov(ecx, ptr[r14d + r12d * 1 - 1000]);
            mov(ecx, ptr[r14d + r12d * 2 + 0]);
            mov(ecx, ptr[r14d + r12d * 2 + 1]);
            mov(ecx, ptr[r14d + r12d * 2 + 1000]);
            mov(ecx, ptr[r14d + r12d * 2 - 1]);
            mov(ecx, ptr[r14d + r12d * 2 - 1000]);
            mov(ecx, ptr[r14d + r12d * 4 + 0]);
            mov(ecx, ptr[r14d + r12d * 4 + 1]);
            mov(ecx, ptr[r14d + r12d * 4 + 1000]);
            mov(ecx, ptr[r14d + r12d * 4 - 1]);
            mov(ecx, ptr[r14d + r12d * 4 - 1000]);
            mov(ecx, ptr[r14d + r12d * 8 + 0]);
            mov(ecx, ptr[r14d + r12d * 8 + 1]);
            mov(ecx, ptr[r14d + r12d * 8 + 1000]);
            mov(ecx, ptr[r14d + r12d * 8 - 1]);
            mov(ecx, ptr[r14d + r12d * 8 - 1000]);
            mov(ecx, ptr[r14d + r13d + 0]);
            mov(ecx, ptr[r14d + r13d + 1]);
            mov(ecx, ptr[r14d + r13d + 1000]);
            mov(ecx, ptr[r14d + r13d - 1]);
            mov(ecx, ptr[r14d + r13d - 1000]);
            mov(ecx, ptr[r14d + r13d * 1 + 0]);
            mov(ecx, ptr[r14d + r13d * 1 + 1]);
            mov(ecx, ptr[r14d + r13d * 1 + 1000]);
            mov(ecx, ptr[r14d + r13d * 1 - 1]);
            mov(ecx, ptr[r14d + r13d * 1 - 1000]);
            mov(ecx, ptr[r14d + r13d * 2 + 0]);
            mov(ecx, ptr[r14d + r13d * 2 + 1]);
            mov(ecx, ptr[r14d + r13d * 2 + 1000]);
            mov(ecx, ptr[r14d + r13d * 2 - 1]);
            mov(ecx, ptr[r14d + r13d * 2 - 1000]);
            mov(ecx, ptr[r14d + r13d * 4 + 0]);
            mov(ecx, ptr[r14d + r13d * 4 + 1]);
            mov(ecx, ptr[r14d + r13d * 4 + 1000]);
            mov(ecx, ptr[r14d + r13d * 4 - 1]);
            mov(ecx, ptr[r14d + r13d * 4 - 1000]);
            mov(ecx, ptr[r14d + r13d * 8 + 0]);
            mov(ecx, ptr[r14d + r13d * 8 + 1]);
            mov(ecx, ptr[r14d + r13d * 8 + 1000]);
            mov(ecx, ptr[r14d + r13d * 8 - 1]);
            mov(ecx, ptr[r14d + r13d * 8 - 1000]);
            mov(ecx, ptr[r14d + r14d + 0]);
            mov(ecx, ptr[r14d + r14d + 1]);
            mov(ecx, ptr[r14d + r14d + 1000]);
            mov(ecx, ptr[r14d + r14d - 1]);
            mov(ecx, ptr[r14d + r14d - 1000]);
            mov(ecx, ptr[r14d + r14d * 1 + 0]);
            mov(ecx, ptr[r14d + r14d * 1 + 1]);
            mov(ecx, ptr[r14d + r14d * 1 + 1000]);
            mov(ecx, ptr[r14d + r14d * 1 - 1]);
            mov(ecx, ptr[r14d + r14d * 1 - 1000]);
            mov(ecx, ptr[r14d + r14d * 2 + 0]);
            mov(ecx, ptr[r14d + r14d * 2 + 1]);
            mov(ecx, ptr[r14d + r14d * 2 + 1000]);
            mov(ecx, ptr[r14d + r14d * 2 - 1]);
            mov(ecx, ptr[r14d + r14d * 2 - 1000]);
            mov(ecx, ptr[r14d + r14d * 4 + 0]);
            mov(ecx, ptr[r14d + r14d * 4 + 1]);
            mov(ecx, ptr[r14d + r14d * 4 + 1000]);
            mov(ecx, ptr[r14d + r14d * 4 - 1]);
            mov(ecx, ptr[r14d + r14d * 4 - 1000]);
            mov(ecx, ptr[r14d + r14d * 8 + 0]);
            mov(ecx, ptr[r14d + r14d * 8 + 1]);
            mov(ecx, ptr[r14d + r14d * 8 + 1000]);
            mov(ecx, ptr[r14d + r14d * 8 - 1]);
            mov(ecx, ptr[r14d + r14d * 8 - 1000]);
            mov(ecx, ptr[r14d + r15d + 0]);
            mov(ecx, ptr[r14d + r15d + 1]);
            mov(ecx, ptr[r14d + r15d + 1000]);
            mov(ecx, ptr[r14d + r15d - 1]);
            mov(ecx, ptr[r14d + r15d - 1000]);
            mov(ecx, ptr[r14d + r15d * 1 + 0]);
            mov(ecx, ptr[r14d + r15d * 1 + 1]);
            mov(ecx, ptr[r14d + r15d * 1 + 1000]);
            mov(ecx, ptr[r14d + r15d * 1 - 1]);
            mov(ecx, ptr[r14d + r15d * 1 - 1000]);
            mov(ecx, ptr[r14d + r15d * 2 + 0]);
            mov(ecx, ptr[r14d + r15d * 2 + 1]);
            mov(ecx, ptr[r14d + r15d * 2 + 1000]);
            mov(ecx, ptr[r14d + r15d * 2 - 1]);
            mov(ecx, ptr[r14d + r15d * 2 - 1000]);
            mov(ecx, ptr[r14d + r15d * 4 + 0]);
            mov(ecx, ptr[r14d + r15d * 4 + 1]);
            mov(ecx, ptr[r14d + r15d * 4 + 1000]);
            mov(ecx, ptr[r14d + r15d * 4 - 1]);
            mov(ecx, ptr[r14d + r15d * 4 - 1000]);
            mov(ecx, ptr[r14d + r15d * 8 + 0]);
            mov(ecx, ptr[r14d + r15d * 8 + 1]);
            mov(ecx, ptr[r14d + r15d * 8 + 1000]);
            mov(ecx, ptr[r14d + r15d * 8 - 1]);
            mov(ecx, ptr[r14d + r15d * 8 - 1000]);
        }
    }

    class gen49 : CodeGenerator {
        this()
        {
            mov(ecx, ptr[r15d + eax + 0]);
            mov(ecx, ptr[r15d + eax + 1]);
            mov(ecx, ptr[r15d + eax + 1000]);
            mov(ecx, ptr[r15d + eax - 1]);
            mov(ecx, ptr[r15d + eax - 1000]);
            mov(ecx, ptr[r15d + eax * 1 + 0]);
            mov(ecx, ptr[r15d + eax * 1 + 1]);
            mov(ecx, ptr[r15d + eax * 1 + 1000]);
            mov(ecx, ptr[r15d + eax * 1 - 1]);
            mov(ecx, ptr[r15d + eax * 1 - 1000]);
            mov(ecx, ptr[r15d + eax * 2 + 0]);
            mov(ecx, ptr[r15d + eax * 2 + 1]);
            mov(ecx, ptr[r15d + eax * 2 + 1000]);
            mov(ecx, ptr[r15d + eax * 2 - 1]);
            mov(ecx, ptr[r15d + eax * 2 - 1000]);
            mov(ecx, ptr[r15d + eax * 4 + 0]);
            mov(ecx, ptr[r15d + eax * 4 + 1]);
            mov(ecx, ptr[r15d + eax * 4 + 1000]);
            mov(ecx, ptr[r15d + eax * 4 - 1]);
            mov(ecx, ptr[r15d + eax * 4 - 1000]);
            mov(ecx, ptr[r15d + eax * 8 + 0]);
            mov(ecx, ptr[r15d + eax * 8 + 1]);
            mov(ecx, ptr[r15d + eax * 8 + 1000]);
            mov(ecx, ptr[r15d + eax * 8 - 1]);
            mov(ecx, ptr[r15d + eax * 8 - 1000]);
            mov(ecx, ptr[r15d + ecx + 0]);
            mov(ecx, ptr[r15d + ecx + 1]);
            mov(ecx, ptr[r15d + ecx + 1000]);
            mov(ecx, ptr[r15d + ecx - 1]);
            mov(ecx, ptr[r15d + ecx - 1000]);
            mov(ecx, ptr[r15d + ecx * 1 + 0]);
            mov(ecx, ptr[r15d + ecx * 1 + 1]);
            mov(ecx, ptr[r15d + ecx * 1 + 1000]);
            mov(ecx, ptr[r15d + ecx * 1 - 1]);
            mov(ecx, ptr[r15d + ecx * 1 - 1000]);
            mov(ecx, ptr[r15d + ecx * 2 + 0]);
            mov(ecx, ptr[r15d + ecx * 2 + 1]);
            mov(ecx, ptr[r15d + ecx * 2 + 1000]);
            mov(ecx, ptr[r15d + ecx * 2 - 1]);
            mov(ecx, ptr[r15d + ecx * 2 - 1000]);
            mov(ecx, ptr[r15d + ecx * 4 + 0]);
            mov(ecx, ptr[r15d + ecx * 4 + 1]);
            mov(ecx, ptr[r15d + ecx * 4 + 1000]);
            mov(ecx, ptr[r15d + ecx * 4 - 1]);
            mov(ecx, ptr[r15d + ecx * 4 - 1000]);
            mov(ecx, ptr[r15d + ecx * 8 + 0]);
            mov(ecx, ptr[r15d + ecx * 8 + 1]);
            mov(ecx, ptr[r15d + ecx * 8 + 1000]);
            mov(ecx, ptr[r15d + ecx * 8 - 1]);
            mov(ecx, ptr[r15d + ecx * 8 - 1000]);
            mov(ecx, ptr[r15d + edx + 0]);
            mov(ecx, ptr[r15d + edx + 1]);
            mov(ecx, ptr[r15d + edx + 1000]);
            mov(ecx, ptr[r15d + edx - 1]);
            mov(ecx, ptr[r15d + edx - 1000]);
            mov(ecx, ptr[r15d + edx * 1 + 0]);
            mov(ecx, ptr[r15d + edx * 1 + 1]);
            mov(ecx, ptr[r15d + edx * 1 + 1000]);
            mov(ecx, ptr[r15d + edx * 1 - 1]);
            mov(ecx, ptr[r15d + edx * 1 - 1000]);
            mov(ecx, ptr[r15d + edx * 2 + 0]);
            mov(ecx, ptr[r15d + edx * 2 + 1]);
            mov(ecx, ptr[r15d + edx * 2 + 1000]);
            mov(ecx, ptr[r15d + edx * 2 - 1]);
            mov(ecx, ptr[r15d + edx * 2 - 1000]);
            mov(ecx, ptr[r15d + edx * 4 + 0]);
            mov(ecx, ptr[r15d + edx * 4 + 1]);
            mov(ecx, ptr[r15d + edx * 4 + 1000]);
            mov(ecx, ptr[r15d + edx * 4 - 1]);
            mov(ecx, ptr[r15d + edx * 4 - 1000]);
            mov(ecx, ptr[r15d + edx * 8 + 0]);
            mov(ecx, ptr[r15d + edx * 8 + 1]);
            mov(ecx, ptr[r15d + edx * 8 + 1000]);
            mov(ecx, ptr[r15d + edx * 8 - 1]);
            mov(ecx, ptr[r15d + edx * 8 - 1000]);
            mov(ecx, ptr[r15d + ebx + 0]);
            mov(ecx, ptr[r15d + ebx + 1]);
            mov(ecx, ptr[r15d + ebx + 1000]);
            mov(ecx, ptr[r15d + ebx - 1]);
            mov(ecx, ptr[r15d + ebx - 1000]);
            mov(ecx, ptr[r15d + ebx * 1 + 0]);
            mov(ecx, ptr[r15d + ebx * 1 + 1]);
            mov(ecx, ptr[r15d + ebx * 1 + 1000]);
            mov(ecx, ptr[r15d + ebx * 1 - 1]);
            mov(ecx, ptr[r15d + ebx * 1 - 1000]);
            mov(ecx, ptr[r15d + ebx * 2 + 0]);
            mov(ecx, ptr[r15d + ebx * 2 + 1]);
            mov(ecx, ptr[r15d + ebx * 2 + 1000]);
            mov(ecx, ptr[r15d + ebx * 2 - 1]);
            mov(ecx, ptr[r15d + ebx * 2 - 1000]);
            mov(ecx, ptr[r15d + ebx * 4 + 0]);
            mov(ecx, ptr[r15d + ebx * 4 + 1]);
            mov(ecx, ptr[r15d + ebx * 4 + 1000]);
            mov(ecx, ptr[r15d + ebx * 4 - 1]);
            mov(ecx, ptr[r15d + ebx * 4 - 1000]);
            mov(ecx, ptr[r15d + ebx * 8 + 0]);
            mov(ecx, ptr[r15d + ebx * 8 + 1]);
            mov(ecx, ptr[r15d + ebx * 8 + 1000]);
            mov(ecx, ptr[r15d + ebx * 8 - 1]);
            mov(ecx, ptr[r15d + ebx * 8 - 1000]);
        }
    }

    class gen50 : CodeGenerator {
        this()
        {
            mov(ecx, ptr[r15d + ebp + 0]);
            mov(ecx, ptr[r15d + ebp + 1]);
            mov(ecx, ptr[r15d + ebp + 1000]);
            mov(ecx, ptr[r15d + ebp - 1]);
            mov(ecx, ptr[r15d + ebp - 1000]);
            mov(ecx, ptr[r15d + ebp * 1 + 0]);
            mov(ecx, ptr[r15d + ebp * 1 + 1]);
            mov(ecx, ptr[r15d + ebp * 1 + 1000]);
            mov(ecx, ptr[r15d + ebp * 1 - 1]);
            mov(ecx, ptr[r15d + ebp * 1 - 1000]);
            mov(ecx, ptr[r15d + ebp * 2 + 0]);
            mov(ecx, ptr[r15d + ebp * 2 + 1]);
            mov(ecx, ptr[r15d + ebp * 2 + 1000]);
            mov(ecx, ptr[r15d + ebp * 2 - 1]);
            mov(ecx, ptr[r15d + ebp * 2 - 1000]);
            mov(ecx, ptr[r15d + ebp * 4 + 0]);
            mov(ecx, ptr[r15d + ebp * 4 + 1]);
            mov(ecx, ptr[r15d + ebp * 4 + 1000]);
            mov(ecx, ptr[r15d + ebp * 4 - 1]);
            mov(ecx, ptr[r15d + ebp * 4 - 1000]);
            mov(ecx, ptr[r15d + ebp * 8 + 0]);
            mov(ecx, ptr[r15d + ebp * 8 + 1]);
            mov(ecx, ptr[r15d + ebp * 8 + 1000]);
            mov(ecx, ptr[r15d + ebp * 8 - 1]);
            mov(ecx, ptr[r15d + ebp * 8 - 1000]);
            mov(ecx, ptr[r15d + esi + 0]);
            mov(ecx, ptr[r15d + esi + 1]);
            mov(ecx, ptr[r15d + esi + 1000]);
            mov(ecx, ptr[r15d + esi - 1]);
            mov(ecx, ptr[r15d + esi - 1000]);
            mov(ecx, ptr[r15d + esi * 1 + 0]);
            mov(ecx, ptr[r15d + esi * 1 + 1]);
            mov(ecx, ptr[r15d + esi * 1 + 1000]);
            mov(ecx, ptr[r15d + esi * 1 - 1]);
            mov(ecx, ptr[r15d + esi * 1 - 1000]);
            mov(ecx, ptr[r15d + esi * 2 + 0]);
            mov(ecx, ptr[r15d + esi * 2 + 1]);
            mov(ecx, ptr[r15d + esi * 2 + 1000]);
            mov(ecx, ptr[r15d + esi * 2 - 1]);
            mov(ecx, ptr[r15d + esi * 2 - 1000]);
            mov(ecx, ptr[r15d + esi * 4 + 0]);
            mov(ecx, ptr[r15d + esi * 4 + 1]);
            mov(ecx, ptr[r15d + esi * 4 + 1000]);
            mov(ecx, ptr[r15d + esi * 4 - 1]);
            mov(ecx, ptr[r15d + esi * 4 - 1000]);
            mov(ecx, ptr[r15d + esi * 8 + 0]);
            mov(ecx, ptr[r15d + esi * 8 + 1]);
            mov(ecx, ptr[r15d + esi * 8 + 1000]);
            mov(ecx, ptr[r15d + esi * 8 - 1]);
            mov(ecx, ptr[r15d + esi * 8 - 1000]);
            mov(ecx, ptr[r15d + edi + 0]);
            mov(ecx, ptr[r15d + edi + 1]);
            mov(ecx, ptr[r15d + edi + 1000]);
            mov(ecx, ptr[r15d + edi - 1]);
            mov(ecx, ptr[r15d + edi - 1000]);
            mov(ecx, ptr[r15d + edi * 1 + 0]);
            mov(ecx, ptr[r15d + edi * 1 + 1]);
            mov(ecx, ptr[r15d + edi * 1 + 1000]);
            mov(ecx, ptr[r15d + edi * 1 - 1]);
            mov(ecx, ptr[r15d + edi * 1 - 1000]);
            mov(ecx, ptr[r15d + edi * 2 + 0]);
            mov(ecx, ptr[r15d + edi * 2 + 1]);
            mov(ecx, ptr[r15d + edi * 2 + 1000]);
            mov(ecx, ptr[r15d + edi * 2 - 1]);
            mov(ecx, ptr[r15d + edi * 2 - 1000]);
            mov(ecx, ptr[r15d + edi * 4 + 0]);
            mov(ecx, ptr[r15d + edi * 4 + 1]);
            mov(ecx, ptr[r15d + edi * 4 + 1000]);
            mov(ecx, ptr[r15d + edi * 4 - 1]);
            mov(ecx, ptr[r15d + edi * 4 - 1000]);
            mov(ecx, ptr[r15d + edi * 8 + 0]);
            mov(ecx, ptr[r15d + edi * 8 + 1]);
            mov(ecx, ptr[r15d + edi * 8 + 1000]);
            mov(ecx, ptr[r15d + edi * 8 - 1]);
            mov(ecx, ptr[r15d + edi * 8 - 1000]);
            mov(ecx, ptr[r15d + r9d + 0]);
            mov(ecx, ptr[r15d + r9d + 1]);
            mov(ecx, ptr[r15d + r9d + 1000]);
            mov(ecx, ptr[r15d + r9d - 1]);
            mov(ecx, ptr[r15d + r9d - 1000]);
            mov(ecx, ptr[r15d + r9d * 1 + 0]);
            mov(ecx, ptr[r15d + r9d * 1 + 1]);
            mov(ecx, ptr[r15d + r9d * 1 + 1000]);
            mov(ecx, ptr[r15d + r9d * 1 - 1]);
            mov(ecx, ptr[r15d + r9d * 1 - 1000]);
            mov(ecx, ptr[r15d + r9d * 2 + 0]);
            mov(ecx, ptr[r15d + r9d * 2 + 1]);
            mov(ecx, ptr[r15d + r9d * 2 + 1000]);
            mov(ecx, ptr[r15d + r9d * 2 - 1]);
            mov(ecx, ptr[r15d + r9d * 2 - 1000]);
            mov(ecx, ptr[r15d + r9d * 4 + 0]);
            mov(ecx, ptr[r15d + r9d * 4 + 1]);
            mov(ecx, ptr[r15d + r9d * 4 + 1000]);
            mov(ecx, ptr[r15d + r9d * 4 - 1]);
            mov(ecx, ptr[r15d + r9d * 4 - 1000]);
            mov(ecx, ptr[r15d + r9d * 8 + 0]);
            mov(ecx, ptr[r15d + r9d * 8 + 1]);
            mov(ecx, ptr[r15d + r9d * 8 + 1000]);
            mov(ecx, ptr[r15d + r9d * 8 - 1]);
            mov(ecx, ptr[r15d + r9d * 8 - 1000]);
        }
    }

    class gen51 : CodeGenerator {
        this()
        {
            mov(ecx, ptr[r15d + r10d + 0]);
            mov(ecx, ptr[r15d + r10d + 1]);
            mov(ecx, ptr[r15d + r10d + 1000]);
            mov(ecx, ptr[r15d + r10d - 1]);
            mov(ecx, ptr[r15d + r10d - 1000]);
            mov(ecx, ptr[r15d + r10d * 1 + 0]);
            mov(ecx, ptr[r15d + r10d * 1 + 1]);
            mov(ecx, ptr[r15d + r10d * 1 + 1000]);
            mov(ecx, ptr[r15d + r10d * 1 - 1]);
            mov(ecx, ptr[r15d + r10d * 1 - 1000]);
            mov(ecx, ptr[r15d + r10d * 2 + 0]);
            mov(ecx, ptr[r15d + r10d * 2 + 1]);
            mov(ecx, ptr[r15d + r10d * 2 + 1000]);
            mov(ecx, ptr[r15d + r10d * 2 - 1]);
            mov(ecx, ptr[r15d + r10d * 2 - 1000]);
            mov(ecx, ptr[r15d + r10d * 4 + 0]);
            mov(ecx, ptr[r15d + r10d * 4 + 1]);
            mov(ecx, ptr[r15d + r10d * 4 + 1000]);
            mov(ecx, ptr[r15d + r10d * 4 - 1]);
            mov(ecx, ptr[r15d + r10d * 4 - 1000]);
            mov(ecx, ptr[r15d + r10d * 8 + 0]);
            mov(ecx, ptr[r15d + r10d * 8 + 1]);
            mov(ecx, ptr[r15d + r10d * 8 + 1000]);
            mov(ecx, ptr[r15d + r10d * 8 - 1]);
            mov(ecx, ptr[r15d + r10d * 8 - 1000]);
            mov(ecx, ptr[r15d + r11d + 0]);
            mov(ecx, ptr[r15d + r11d + 1]);
            mov(ecx, ptr[r15d + r11d + 1000]);
            mov(ecx, ptr[r15d + r11d - 1]);
            mov(ecx, ptr[r15d + r11d - 1000]);
            mov(ecx, ptr[r15d + r11d * 1 + 0]);
            mov(ecx, ptr[r15d + r11d * 1 + 1]);
            mov(ecx, ptr[r15d + r11d * 1 + 1000]);
            mov(ecx, ptr[r15d + r11d * 1 - 1]);
            mov(ecx, ptr[r15d + r11d * 1 - 1000]);
            mov(ecx, ptr[r15d + r11d * 2 + 0]);
            mov(ecx, ptr[r15d + r11d * 2 + 1]);
            mov(ecx, ptr[r15d + r11d * 2 + 1000]);
            mov(ecx, ptr[r15d + r11d * 2 - 1]);
            mov(ecx, ptr[r15d + r11d * 2 - 1000]);
            mov(ecx, ptr[r15d + r11d * 4 + 0]);
            mov(ecx, ptr[r15d + r11d * 4 + 1]);
            mov(ecx, ptr[r15d + r11d * 4 + 1000]);
            mov(ecx, ptr[r15d + r11d * 4 - 1]);
            mov(ecx, ptr[r15d + r11d * 4 - 1000]);
            mov(ecx, ptr[r15d + r11d * 8 + 0]);
            mov(ecx, ptr[r15d + r11d * 8 + 1]);
            mov(ecx, ptr[r15d + r11d * 8 + 1000]);
            mov(ecx, ptr[r15d + r11d * 8 - 1]);
            mov(ecx, ptr[r15d + r11d * 8 - 1000]);
            mov(ecx, ptr[r15d + r12d + 0]);
            mov(ecx, ptr[r15d + r12d + 1]);
            mov(ecx, ptr[r15d + r12d + 1000]);
            mov(ecx, ptr[r15d + r12d - 1]);
            mov(ecx, ptr[r15d + r12d - 1000]);
            mov(ecx, ptr[r15d + r12d * 1 + 0]);
            mov(ecx, ptr[r15d + r12d * 1 + 1]);
            mov(ecx, ptr[r15d + r12d * 1 + 1000]);
            mov(ecx, ptr[r15d + r12d * 1 - 1]);
            mov(ecx, ptr[r15d + r12d * 1 - 1000]);
            mov(ecx, ptr[r15d + r12d * 2 + 0]);
            mov(ecx, ptr[r15d + r12d * 2 + 1]);
            mov(ecx, ptr[r15d + r12d * 2 + 1000]);
            mov(ecx, ptr[r15d + r12d * 2 - 1]);
            mov(ecx, ptr[r15d + r12d * 2 - 1000]);
            mov(ecx, ptr[r15d + r12d * 4 + 0]);
            mov(ecx, ptr[r15d + r12d * 4 + 1]);
            mov(ecx, ptr[r15d + r12d * 4 + 1000]);
            mov(ecx, ptr[r15d + r12d * 4 - 1]);
            mov(ecx, ptr[r15d + r12d * 4 - 1000]);
            mov(ecx, ptr[r15d + r12d * 8 + 0]);
            mov(ecx, ptr[r15d + r12d * 8 + 1]);
            mov(ecx, ptr[r15d + r12d * 8 + 1000]);
            mov(ecx, ptr[r15d + r12d * 8 - 1]);
            mov(ecx, ptr[r15d + r12d * 8 - 1000]);
            mov(ecx, ptr[r15d + r13d + 0]);
            mov(ecx, ptr[r15d + r13d + 1]);
            mov(ecx, ptr[r15d + r13d + 1000]);
            mov(ecx, ptr[r15d + r13d - 1]);
            mov(ecx, ptr[r15d + r13d - 1000]);
            mov(ecx, ptr[r15d + r13d * 1 + 0]);
            mov(ecx, ptr[r15d + r13d * 1 + 1]);
            mov(ecx, ptr[r15d + r13d * 1 + 1000]);
            mov(ecx, ptr[r15d + r13d * 1 - 1]);
            mov(ecx, ptr[r15d + r13d * 1 - 1000]);
            mov(ecx, ptr[r15d + r13d * 2 + 0]);
            mov(ecx, ptr[r15d + r13d * 2 + 1]);
            mov(ecx, ptr[r15d + r13d * 2 + 1000]);
            mov(ecx, ptr[r15d + r13d * 2 - 1]);
            mov(ecx, ptr[r15d + r13d * 2 - 1000]);
            mov(ecx, ptr[r15d + r13d * 4 + 0]);
            mov(ecx, ptr[r15d + r13d * 4 + 1]);
            mov(ecx, ptr[r15d + r13d * 4 + 1000]);
            mov(ecx, ptr[r15d + r13d * 4 - 1]);
            mov(ecx, ptr[r15d + r13d * 4 - 1000]);
            mov(ecx, ptr[r15d + r13d * 8 + 0]);
            mov(ecx, ptr[r15d + r13d * 8 + 1]);
            mov(ecx, ptr[r15d + r13d * 8 + 1000]);
            mov(ecx, ptr[r15d + r13d * 8 - 1]);
            mov(ecx, ptr[r15d + r13d * 8 - 1000]);
        }
    }

    class gen52 : CodeGenerator {
        this()
        {
            mov(ecx, ptr[r15d + r14d + 0]);
            mov(ecx, ptr[r15d + r14d + 1]);
            mov(ecx, ptr[r15d + r14d + 1000]);
            mov(ecx, ptr[r15d + r14d - 1]);
            mov(ecx, ptr[r15d + r14d - 1000]);
            mov(ecx, ptr[r15d + r14d * 1 + 0]);
            mov(ecx, ptr[r15d + r14d * 1 + 1]);
            mov(ecx, ptr[r15d + r14d * 1 + 1000]);
            mov(ecx, ptr[r15d + r14d * 1 - 1]);
            mov(ecx, ptr[r15d + r14d * 1 - 1000]);
            mov(ecx, ptr[r15d + r14d * 2 + 0]);
            mov(ecx, ptr[r15d + r14d * 2 + 1]);
            mov(ecx, ptr[r15d + r14d * 2 + 1000]);
            mov(ecx, ptr[r15d + r14d * 2 - 1]);
            mov(ecx, ptr[r15d + r14d * 2 - 1000]);
            mov(ecx, ptr[r15d + r14d * 4 + 0]);
            mov(ecx, ptr[r15d + r14d * 4 + 1]);
            mov(ecx, ptr[r15d + r14d * 4 + 1000]);
            mov(ecx, ptr[r15d + r14d * 4 - 1]);
            mov(ecx, ptr[r15d + r14d * 4 - 1000]);
            mov(ecx, ptr[r15d + r14d * 8 + 0]);
            mov(ecx, ptr[r15d + r14d * 8 + 1]);
            mov(ecx, ptr[r15d + r14d * 8 + 1000]);
            mov(ecx, ptr[r15d + r14d * 8 - 1]);
            mov(ecx, ptr[r15d + r14d * 8 - 1000]);
            mov(ecx, ptr[r15d + r15d + 0]);
            mov(ecx, ptr[r15d + r15d + 1]);
            mov(ecx, ptr[r15d + r15d + 1000]);
            mov(ecx, ptr[r15d + r15d - 1]);
            mov(ecx, ptr[r15d + r15d - 1000]);
            mov(ecx, ptr[r15d + r15d * 1 + 0]);
            mov(ecx, ptr[r15d + r15d * 1 + 1]);
            mov(ecx, ptr[r15d + r15d * 1 + 1000]);
            mov(ecx, ptr[r15d + r15d * 1 - 1]);
            mov(ecx, ptr[r15d + r15d * 1 - 1000]);
            mov(ecx, ptr[r15d + r15d * 2 + 0]);
            mov(ecx, ptr[r15d + r15d * 2 + 1]);
            mov(ecx, ptr[r15d + r15d * 2 + 1000]);
            mov(ecx, ptr[r15d + r15d * 2 - 1]);
            mov(ecx, ptr[r15d + r15d * 2 - 1000]);
            mov(ecx, ptr[r15d + r15d * 4 + 0]);
            mov(ecx, ptr[r15d + r15d * 4 + 1]);
            mov(ecx, ptr[r15d + r15d * 4 + 1000]);
            mov(ecx, ptr[r15d + r15d * 4 - 1]);
            mov(ecx, ptr[r15d + r15d * 4 - 1000]);
            mov(ecx, ptr[r15d + r15d * 8 + 0]);
            mov(ecx, ptr[r15d + r15d * 8 + 1]);
            mov(ecx, ptr[r15d + r15d * 8 + 1000]);
            mov(ecx, ptr[r15d + r15d * 8 - 1]);
            mov(ecx, ptr[r15d + r15d * 8 - 1000]);
        }
    }


    version(XBYAK64)
    {
        class genVsib : CodeGenerator
        {
            this()
            {
                vgatherdpd(ymm7, ptr[xmm0], ymm4);
                vgatherdpd(ymm7, ptr[xmm0 * 1], ymm4);
                vgatherdpd(ymm7, ptr[xmm0 + 4], ymm4);
                vgatherdpd(ymm7, ptr[xmm0 + eax], ymm4);
                vgatherdpd(ymm7, ptr[xmm0 * 4 + ecx], ymm4);
                vgatherdpd(ymm7, ptr[xmm3 * 8 + edi + 123], ymm4);
                vgatherdpd(ymm7, ptr[xmm2 * 2 + 5], ymm4);
                vgatherdpd(ymm7, ptr[eax + xmm0], ymm4);
                vgatherdpd(ymm7, ptr[esp + xmm4], ymm4);

                vgatherqpd(ymm7, ptr[ymm0], ymm4);
                vgatherqpd(ymm7, ptr[ymm0 * 1], ymm4);
                vgatherqpd(ymm7, ptr[ymm0 + 4], ymm4);
                vgatherqpd(ymm7, ptr[ymm0 + eax], ymm4);
                vgatherqpd(ymm7, ptr[ymm0 * 4 + ecx], ymm4);
                vgatherqpd(ymm7, ptr[ymm3 * 8 + edi + 123], ymm4);
                vgatherqpd(ymm7, ptr[ymm2 * 2 + 5], ymm4);
                vgatherqpd(ymm7, ptr[eax + ymm0], ymm4);
                vgatherqpd(ymm7, ptr[esp + ymm4], ymm4);
                vgatherdpd(ymm7, ptr[xmm0 + r11], ymm4);
                vgatherdpd(ymm7, ptr[r13 + xmm15], ymm4);
                vgatherdpd(ymm7, ptr[123 + rsi + xmm2 * 4], ymm4);
            }
        }
    }

    auto g0  = new gen0();
    auto g1  = new gen1();
    auto g2  = new gen2();
    auto g3  = new gen3();
    auto g4  = new gen4();
    auto g5  = new gen5();
    auto g6  = new gen6();
    auto g7  = new gen7();
    auto g8  = new gen8();
    auto g9  = new gen9();
    auto g10 = new gen10();
    auto g11 = new gen11();
    auto g12 = new gen12();
    auto g13 = new gen13();
    auto g14 = new gen14();
    auto g15 = new gen15();
    auto g16 = new gen16();
    auto g17 = new gen17();
    auto g18 = new gen18();
    auto g19 = new gen19();
    auto g20 = new gen20();
    auto g21 = new gen21();
    auto g22 = new gen22();
    auto g23 = new gen23();
    auto g24 = new gen24();
    auto g25 = new gen25();
    auto g26 = new gen26();
    auto g27 = new gen27();
    auto g28 = new gen28();
    auto g29 = new gen29();
    auto g30 = new gen30();
    auto g31 = new gen31();
    auto g32 = new gen32();
    auto g33 = new gen33();
    auto g34 = new gen34();
    auto g35 = new gen35();
    auto g36 = new gen36();
    auto g37 = new gen37();
    auto g38 = new gen38();
    auto g39 = new gen39();
    auto g40 = new gen40();
    auto g41 = new gen41();
    auto g42 = new gen42();
    auto g43 = new gen43();
    auto g44 = new gen44();
    auto g45 = new gen45();
    auto g46 = new gen46();
    auto g47 = new gen47();
    auto g48 = new gen48();
    auto g49 = new gen49();
    auto g50 = new gen50();
    auto g51 = new gen51();
    auto g52 = new gen52();

    auto gV = new genVsib();
}
